From 152e3751d8213bd8799fa006c2f2bb9185661989 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Fri, 6 Feb 2026 21:54:51 +0100
Subject: [PATCH 1/5] feat(format): add case pipe for VALUE/NAME

Adds "case:<style>" pipe option for {{VALUE}}/{{NAME}}/{{VALUE:<var>}} to transform resolved values (kebab/snake/camel/pascal/title/lower/upper) at render time without mutating stored variables.

Refs #90
---
 docs/docs/FormatSyntax.md                  |   3 +-
 src/constants.ts                           |   6 +
 src/formatters/formatter-case.test.ts      | 142 +++++++++++++++++++++
 src/formatters/formatter.ts                |  20 ++-
 src/preflight/RequirementCollector.test.ts |  21 +++
 src/utils/caseTransform.ts                 |  84 ++++++++++++
 src/utils/valueSyntax.test.ts              |  20 +++
 src/utils/valueSyntax.ts                   |  16 ++-
 8 files changed, 305 insertions(+), 7 deletions(-)
 create mode 100644 src/formatters/formatter-case.test.ts
 create mode 100644 src/utils/caseTransform.ts

diff --git a/docs/docs/FormatSyntax.md b/docs/docs/FormatSyntax.md
index 48be5dcd..5fcaf151 100644
--- a/docs/docs/FormatSyntax.md
+++ b/docs/docs/FormatSyntax.md
@@ -11,9 +11,10 @@ title: Format syntax
 | `{{VALUE}}` or `{{NAME}}`                  | Interchangeable. Represents the value given in an input prompt. If text is selected in the current editor, it will be used as the value. For Capture choices, selection-as-value can be disabled globally or per-capture. When using the QuickAdd API, this can be passed programmatically using the reserved variable name 'value'.<br/><br/>**Macro note:** `{{VALUE}}` / `{{NAME}}` are scoped per template step, so each template in a macro prompts independently. Use `{{VALUE:sharedName}}` when you want one prompt reused across the macro. |
 | `{{VALUE:<variable name>}}`                  | You can now use variable names in values. They'll get saved and inserted just like values, but the difference is that you can have as many of them as you want. Use comma separation to get a suggester rather than a prompt.<br/><br/>If the same variable name appears in multiple macro steps, QuickAdd prompts once and reuses the value. |
 | `{{VALUE:<variable name>\|label:<helper text>}}`     | Adds helper text to the prompt for a single-value input. The helper appears below the header and is useful for reminders or instructions. For multi-value lists, use the same syntax to label the suggester (e.g., `{{VALUE:Red,Green,Blue\|label:Pick a color}}`). |
-| `{{VALUE:<variable name>\|<default>}}`        | Same as above, but with a default value. For single-value prompts (e.g., `{{VALUE:name\|Anonymous}}`), the default is pre-populated in the input field - press Enter to accept or clear/edit it. For multi-value suggesters without `\|custom`, you must select one of the provided options (no default applies). If you combine options like `\|label:...`, use `\|default:<value>` instead of the shorthand (mixing option keys with a bare default is not supported). |
+| `{{VALUE:<variable name>\|<default>}}`        | Same as above, but with a default value. For single-value prompts (e.g., `{{VALUE:name\|Anonymous}}`), the default is pre-populated in the input field - press Enter to accept or clear/edit it. For multi-value suggesters without `\|custom`, you must select one of the provided options (no default applies). If you combine keyed options like `\|label:`, `\|default:`, `\|type:`, or `\|case:`, shorthand defaults like `\|Anonymous` are ignored; use `\|default:Anonymous` instead. |
 | `{{VALUE:<variable name>\|default:<value>}}`        | Option-form default value, required when combining with other options like `\|label:`. Example: `{{VALUE:title\|label:Snake case\|default:My_Title}}`. |
 | `{{VALUE\|type:multiline}}` / `{{VALUE:<variable>\|type:multiline}}` | Forces a multi-line input prompt/textarea for that VALUE token. Only supported for single-value prompts (no comma options / `\|custom`). Overrides the global "Use Multi-line Input Prompt" setting. If `\|type:` is present, shorthand defaults like `\|Some value` are ignored; use `\|default:` instead. |
+| `{{VALUE\|case:<style>}}` / `{{NAME\|case:<style>}}` / `{{VALUE:<variable>\|case:<style>}}` | Transforms the resolved value into a casing style. Supported: `kebab`, `snake`, `camel`, `pascal`, `title`, `lower`, `upper`. Example: `{{VALUE:title\|case:kebab}}` outputs `my-new-blog` when the input is `My New Blog`. |
 | `{{VALUE:<options>\|custom}}`        | Allows you to type custom values in addition to selecting from the provided options. Example: `{{VALUE:Red,Green,Blue\|custom}}` will suggest Red, Green, and Blue, but also allows you to type any other value like "Purple". This is useful when you have common options but want flexibility for edge cases. **Note:** You cannot combine `\|custom` with a shorthand default value - use `\|default:` if you need both. |
 | `{{LINKCURRENT}}`                          | A link to the file from which the template or capture was triggered (`[[link]]` format). When the append-link setting is set to **Enabled (skip if no active file)**, this token resolves to an empty string instead of throwing an error if no note is focused. |
 | `{{FILENAMECURRENT}}`                      | The basename (without extension) of the file from which the template or capture was triggered. Honors the same **required/optional** behavior as `{{LINKCURRENT}}` - when optional and no active file exists, resolves to an empty string. |
diff --git a/src/constants.ts b/src/constants.ts
index f3fc256d..a013de81 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -9,6 +9,8 @@ export const VARIABLE_DEFAULT_OPTION_SYNTAX =
 	"{{value:<variable name>|default:<value>}}";
 export const VARIABLE_LABEL_SYNTAX =
 	"{{value:<variable name>|label:<helper text>}}";
+export const VALUE_CASE_SYNTAX = "{{value|case:kebab}}";
+export const VARIABLE_CASE_SYNTAX = "{{value:<variable name>|case:kebab}}";
 export const FIELD_VAR_SYNTAX = "{{field:<field name>}}";
 export const MATH_VALUE_SYNTAX = "{{mvalue}}";
 export const LINKCURRENT_SYNTAX = "{{linkcurrent}}";
@@ -27,6 +29,8 @@ export const FORMAT_SYNTAX: string[] = [
 	GLOBAL_VAR_SYNTAX,
 	VALUE_SYNTAX,
 	NAME_SYNTAX,
+	VALUE_CASE_SYNTAX,
+	VARIABLE_CASE_SYNTAX,
 	VARIABLE_SYNTAX,
 	VARIABLE_DEFAULT_SYNTAX,
 	VARIABLE_DEFAULT_OPTION_SYNTAX,
@@ -54,6 +58,8 @@ export const FILE_NAME_FORMAT_SYNTAX: string[] = [
 	GLOBAL_VAR_SYNTAX,
 	VALUE_SYNTAX,
 	NAME_SYNTAX,
+	VALUE_CASE_SYNTAX,
+	VARIABLE_CASE_SYNTAX,
 	VARIABLE_SYNTAX,
 	VARIABLE_DEFAULT_SYNTAX,
 	VARIABLE_DEFAULT_OPTION_SYNTAX,
diff --git a/src/formatters/formatter-case.test.ts b/src/formatters/formatter-case.test.ts
new file mode 100644
index 00000000..5ca8dbed
--- /dev/null
+++ b/src/formatters/formatter-case.test.ts
@@ -0,0 +1,142 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { Formatter } from "./formatter";
+
+class CaseTestFormatter extends Formatter {
+	private valueResponse = "";
+
+	constructor() {
+		super();
+	}
+
+	public setValueResponse(value: string): void {
+		this.valueResponse = value;
+	}
+
+	public setVariable(key: string, value: unknown): void {
+		this.variables.set(key, value);
+	}
+
+	protected async format(input: string): Promise<string> {
+		let output = input;
+		output = await this.replaceValueInString(output);
+		output = await this.replaceVariableInString(output);
+		return output;
+	}
+
+	protected promptForValue(): string {
+		return this.valueResponse;
+	}
+
+	protected getCurrentFileLink(): string | null {
+		return null;
+	}
+
+	protected getCurrentFileName(): string | null {
+		return null;
+	}
+
+	protected getVariableValue(variableName: string): string {
+		const value = this.variables.get(variableName);
+		return typeof value === "string" ? value : "";
+	}
+
+	protected suggestForValue(
+		_suggestedValues: string[],
+		_allowCustomInput?: boolean,
+		_context?: { placeholder?: string; variableKey?: string },
+	): string {
+		return "";
+	}
+
+	protected suggestForField(_variableName: string): Promise<string> {
+		return Promise.resolve("");
+	}
+
+	protected promptForMathValue(): Promise<string> {
+		return Promise.resolve("");
+	}
+
+	protected getMacroValue(
+		_macroName: string,
+		_context?: { label?: string },
+	): string {
+		return "";
+	}
+
+	protected promptForVariable(
+		_variableName: string,
+		_context?: {
+			type?: string;
+			dateFormat?: string;
+			defaultValue?: string;
+			label?: string;
+			description?: string;
+			placeholder?: string;
+			variableKey?: string;
+		},
+	): Promise<string> {
+		return Promise.resolve("");
+	}
+
+	protected getTemplateContent(_templatePath: string): Promise<string> {
+		return Promise.resolve("");
+	}
+
+	protected getSelectedText(): Promise<string> {
+		return Promise.resolve("");
+	}
+
+	protected getClipboardContent(): Promise<string> {
+		return Promise.resolve("");
+	}
+
+	protected isTemplatePropertyTypesEnabled(): boolean {
+		return false;
+	}
+
+	public async testFormat(input: string): Promise<string> {
+		return await this.format(input);
+	}
+}
+
+describe("Formatter case: pipe option", () => {
+	let formatter: CaseTestFormatter;
+
+	beforeEach(() => {
+		formatter = new CaseTestFormatter();
+	});
+
+	it("does not mutate stored named variables; each token applies its own case", async () => {
+		formatter.setVariable("title", "My New Blog");
+		const result = await formatter.testFormat(
+			"title={{VALUE:title}} slug={{VALUE:title|case:kebab}}",
+		);
+		expect(result).toBe("title=My New Blog slug=my-new-blog");
+	});
+
+	it("applies case per token for anonymous VALUE/NAME", async () => {
+		formatter.setValueResponse("My New Blog");
+		const result = await formatter.testFormat(
+			"a={{VALUE}} b={{VALUE|case:kebab}} c={{NAME|case:upper}}",
+		);
+		expect(result).toBe("a=My New Blog b=my-new-blog c=MY NEW BLOG");
+	});
+
+	it("supports snake/camel/pascal/title/lower transforms", async () => {
+		formatter.setValueResponse("my new blog");
+		const result = await formatter.testFormat(
+			"snake={{VALUE|case:snake}} camel={{VALUE|case:camel}} pascal={{VALUE|case:pascal}} title={{VALUE|case:title}} lower={{VALUE|case:lower}}",
+		);
+		expect(result).toBe(
+			"snake=my_new_blog camel=myNewBlog pascal=MyNewBlog title=My New Blog lower=my new blog",
+		);
+	});
+
+	it("ignores unknown case styles (pass-through)", async () => {
+		formatter.setVariable("title", "My New Blog");
+		const result = await formatter.testFormat(
+			"slug={{VALUE:title|case:does-not-exist}}",
+		);
+		expect(result).toBe("slug=My New Blog");
+	});
+});
diff --git a/src/formatters/formatter.ts b/src/formatters/formatter.ts
index 68b99fe1..cbd5c392 100644
--- a/src/formatters/formatter.ts
+++ b/src/formatters/formatter.ts
@@ -26,6 +26,7 @@ import { log } from "../logger/logManager";
 import { TemplatePropertyCollector } from "../utils/TemplatePropertyCollector";
 import { settingsStore } from "../settingsStore";
 import { normalizeDateInput } from "../utils/dateAliases";
+import { transformCase } from "../utils/caseTransform";
 import {
 	parseAnonymousValueOptions,
 	parseValueToken,
@@ -169,7 +170,14 @@ export abstract class Formatter {
 		// Replace all occurrences in a single non-recursive pass.
 		// Important: use a replacer function so `$` in user input is treated literally.
 		const regex = new RegExp(NAME_VALUE_REGEX.source, "gi");
-		output = output.replace(regex, () => this.value);
+		output = output.replace(regex, (token) => {
+			const inner = token.slice(2, -2);
+			const optionsIndex = inner.indexOf("|");
+			if (optionsIndex === -1) return this.value;
+			const rawOptions = inner.slice(optionsIndex);
+			const parsed = parseAnonymousValueOptions(rawOptions);
+			return transformCase(this.value, parsed.caseStyle);
+		});
 
 		return output;
 	}
@@ -319,6 +327,7 @@ export abstract class Formatter {
 				variableName,
 				variableKey,
 				label,
+				caseStyle,
 				defaultValue,
 				allowCustomInput,
 				suggestedValues,
@@ -366,19 +375,24 @@ export abstract class Formatter {
 
 			// Get the raw value from variables
 			const rawValue = this.variables.get(effectiveKey);
+			const rawValueForCollector =
+				caseStyle && typeof rawValue === "string"
+					? transformCase(rawValue, caseStyle)
+					: rawValue;
 
 			// Offer this variable to the property collector for YAML post-processing
 			this.propertyCollector.maybeCollect({
 				input: output,
 				matchStart: match.index,
 				matchEnd: match.index + match[0].length,
-				rawValue,
+				rawValue: rawValueForCollector,
 				fallbackKey: variableName,
 				featureEnabled: propertyTypesEnabled,
 			});
 
 			// Always use string replacement initially
-			const replacement = this.getVariableValue(effectiveKey);
+			const rawReplacement = this.getVariableValue(effectiveKey);
+			const replacement = transformCase(rawReplacement, caseStyle);
 
 			// Replace in output and adjust regex position
 			output = output.slice(0, match.index) + replacement + output.slice(match.index + match[0].length);
diff --git a/src/preflight/RequirementCollector.test.ts b/src/preflight/RequirementCollector.test.ts
index f5979aed..e3c60237 100644
--- a/src/preflight/RequirementCollector.test.ts
+++ b/src/preflight/RequirementCollector.test.ts
@@ -53,6 +53,27 @@ describe("RequirementCollector", () => {
     expect(byId[variableKey].type).toBe("dropdown");
   });
 
+  it("does not treat case option as a legacy default for named VALUE", async () => {
+    const app = makeApp();
+    const plugin = makePlugin();
+    const rc = new RequirementCollector(app, plugin);
+    await rc.scanString("{{VALUE:title|case:kebab}}");
+
+    const requirement = rc.requirements.get("title");
+    expect(requirement?.defaultValue).toBeUndefined();
+  });
+
+  it("does not treat case option as a legacy default for unnamed VALUE", async () => {
+    const app = makeApp();
+    const plugin = makePlugin();
+    const rc = new RequirementCollector(app, plugin);
+    await rc.scanString("{{VALUE|case:kebab|label:Notes}}");
+
+    const requirement = rc.requirements.get("value");
+    expect(requirement?.description).toBe("Notes");
+    expect(requirement?.defaultValue).toBeUndefined();
+  });
+
   it("collects VDATE with format and default", async () => {
     const app = makeApp();
     const plugin = makePlugin();
diff --git a/src/utils/caseTransform.ts b/src/utils/caseTransform.ts
new file mode 100644
index 00000000..522c5d01
--- /dev/null
+++ b/src/utils/caseTransform.ts
@@ -0,0 +1,84 @@
+export type CaseStyle =
+	| "kebab"
+	| "snake"
+	| "camel"
+	| "pascal"
+	| "title"
+	| "lower"
+	| "upper";
+
+function normalizeStyle(style?: string): CaseStyle | null {
+	if (!style) return null;
+	const normalized = style.trim().toLowerCase();
+	switch (normalized) {
+		case "kebab":
+		case "snake":
+		case "camel":
+		case "pascal":
+		case "title":
+		case "lower":
+		case "upper":
+			return normalized;
+		default:
+			return null;
+	}
+}
+
+function upperFirstLowerRest(word: string): string {
+	if (!word) return word;
+	const lower = word.toLowerCase();
+	return lower.slice(0, 1).toUpperCase() + lower.slice(1);
+}
+
+function splitWords(input: string): string[] {
+	let s = input;
+
+	// Handle common camel/pascal boundaries (including acronyms like XMLHttp -> XML Http).
+	s = s.replace(/([\p{Lu}]+)([\p{Lu}][\p{Ll}])/gu, "$1 $2");
+	s = s.replace(/([\p{Ll}\p{N}])([\p{Lu}])/gu, "$1 $2");
+
+	// Split letter <-> number boundaries (Blog2Post -> Blog 2 Post).
+	s = s.replace(/([\p{L}])([\p{N}])/gu, "$1 $2");
+	s = s.replace(/([\p{N}])([\p{L}])/gu, "$1 $2");
+
+	// Treat any non-letter/non-number as separators. Keep combining marks with letters.
+	s = s.replace(/[^\p{L}\p{N}\p{M}]+/gu, " ");
+
+	return s
+		.trim()
+		.split(/\s+/u)
+		.map((w) => w.trim())
+		.filter(Boolean);
+}
+
+export function transformCase(input: string, style?: string): string {
+	const normalized = normalizeStyle(style);
+	if (!normalized) return input;
+
+	if (normalized === "lower") return input.toLowerCase();
+	if (normalized === "upper") return input.toUpperCase();
+
+	const words = splitWords(input);
+	if (words.length === 0) return "";
+
+	switch (normalized) {
+		case "kebab":
+			return words.map((w) => w.toLowerCase()).join("-");
+		case "snake":
+			return words.map((w) => w.toLowerCase()).join("_");
+		case "camel": {
+			const [first, ...rest] = words;
+			return [
+				first?.toLowerCase() ?? "",
+				...rest.map((w) => upperFirstLowerRest(w)),
+			].join("");
+		}
+		case "pascal":
+			return words.map((w) => upperFirstLowerRest(w)).join("");
+		case "title":
+			return words.map((w) => upperFirstLowerRest(w)).join(" ");
+		default:
+			return input;
+	}
+}
+
diff --git a/src/utils/valueSyntax.test.ts b/src/utils/valueSyntax.test.ts
index 9e6aa682..77957c58 100644
--- a/src/utils/valueSyntax.test.ts
+++ b/src/utils/valueSyntax.test.ts
@@ -36,6 +36,17 @@ describe("parseValueToken", () => {
 		expect(parsed?.defaultValue).toBe("label");
 	});
 
+	it("parses case style without treating it as legacy default", () => {
+		const parsed = parseValueToken("title|case:kebab");
+		expect(parsed?.caseStyle).toBe("kebab");
+		expect(parsed?.defaultValue).toBe("");
+	});
+
+	it("parses title case style", () => {
+		const parsed = parseValueToken("title|case:title");
+		expect(parsed?.caseStyle).toBe("title");
+	});
+
 	it("parses custom boolean values", () => {
 		expect(parseValueToken("a,b|custom:")?.allowCustomInput).toBe(true);
 		expect(parseValueToken("a,b|custom:false")?.allowCustomInput).toBe(false);
@@ -93,6 +104,15 @@ describe("parseAnonymousValueOptions", () => {
 		expect(parsed.defaultValue).toBe("Hello");
 	});
 
+	it("parses case style for unnamed VALUE tokens", () => {
+		const parsed = parseAnonymousValueOptions(
+			"|case:kebab|label:Notes|default:Hello",
+		);
+		expect(parsed.caseStyle).toBe("kebab");
+		expect(parsed.label).toBe("Notes");
+		expect(parsed.defaultValue).toBe("Hello");
+	});
+
 	it("warns and ignores unknown type for unnamed VALUE tokens", () => {
 		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
 		const parsed = parseAnonymousValueOptions("|type:wide");
diff --git a/src/utils/valueSyntax.ts b/src/utils/valueSyntax.ts
index 451265be..4fe83be4 100644
--- a/src/utils/valueSyntax.ts
+++ b/src/utils/valueSyntax.ts
@@ -3,13 +3,14 @@ export const VALUE_LABEL_KEY_DELIMITER = "\u001F";
 
 export type ValueInputType = "multiline";
 
-const VALUE_OPTION_KEYS = new Set(["label", "default", "custom", "type"]);
+const VALUE_OPTION_KEYS = new Set(["label", "default", "custom", "type", "case"]);
 
 export type ParsedValueToken = {
 	raw: string;
 	variableName: string;
 	variableKey: string;
 	label?: string;
+	caseStyle?: string;
 	defaultValue: string;
 	allowCustomInput: boolean;
 	suggestedValues: string[];
@@ -74,6 +75,7 @@ export function resolveExistingVariableKey(
 
 type ParsedOptions = {
 	label?: string;
+	caseStyle?: string;
 	defaultValue: string;
 	allowCustomInput: boolean;
 	usesOptions: boolean;
@@ -121,6 +123,7 @@ function parseOptions(optionParts: string[], hasOptions: boolean): ParsedOptions
 	}
 
 	let label: string | undefined;
+	let caseStyle: string | undefined;
 	let defaultValue = "";
 	let allowCustomInput = false;
 	let inputTypeOverride: string | undefined;
@@ -144,6 +147,9 @@ function parseOptions(optionParts: string[], hasOptions: boolean): ParsedOptions
 			case "label":
 				if (value) label = value;
 				break;
+			case "case":
+				if (value) caseStyle = value;
+				break;
 			case "default":
 				defaultValue = value;
 				break;
@@ -160,6 +166,7 @@ function parseOptions(optionParts: string[], hasOptions: boolean): ParsedOptions
 
 	return {
 		label,
+		caseStyle,
 		defaultValue,
 		allowCustomInput,
 		usesOptions: true,
@@ -206,7 +213,7 @@ export function parseValueToken(raw: string): ParsedValueToken | null {
 	const hasOptions = suggestedValues.length > 1;
 
 	const options = parseOptions(parts, hasOptions);
-	let { label, defaultValue, allowCustomInput } = options;
+	let { label, caseStyle, defaultValue, allowCustomInput } = options;
 
 	if (!options.usesOptions) {
 		const legacyDefault = defaultValue;
@@ -228,6 +235,7 @@ export function parseValueToken(raw: string): ParsedValueToken | null {
 		variableName: variablePart,
 		variableKey,
 		label,
+		caseStyle,
 		defaultValue,
 		allowCustomInput,
 		suggestedValues,
@@ -240,6 +248,7 @@ export function parseAnonymousValueOptions(
 	rawOptions: string,
 ): {
 	label?: string;
+	caseStyle?: string;
 	defaultValue: string;
 	inputTypeOverride?: ValueInputType;
 } {
@@ -256,7 +265,7 @@ export function parseAnonymousValueOptions(
 	}
 
 	const options = parseOptions(parts, false);
-	let { label, defaultValue } = options;
+	let { label, caseStyle, defaultValue } = options;
 	if (!options.usesOptions) {
 		defaultValue = defaultValue.trim();
 	}
@@ -270,6 +279,7 @@ export function parseAnonymousValueOptions(
 
 	return {
 		label,
+		caseStyle,
 		defaultValue,
 		inputTypeOverride,
 	};

From bd1418c0998c896fb2e83ad4305a52463b9803f8 Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Fri, 6 Feb 2026 23:20:09 +0100
Subject: [PATCH 2/5] refactor(utils): share pipe parsing helpers

Adds pipeSyntax helpers and reuses them in VALUE option parsing and FIELD filter parsing.
---
 src/utils/FieldSuggestionParser.ts | 17 ++++++++---------
 src/utils/pipeSyntax.ts            | 23 +++++++++++++++++++++++
 src/utils/valueSyntax.ts           | 24 +++++++++++-------------
 3 files changed, 42 insertions(+), 22 deletions(-)
 create mode 100644 src/utils/pipeSyntax.ts

diff --git a/src/utils/FieldSuggestionParser.ts b/src/utils/FieldSuggestionParser.ts
index a7580a35..3c22223c 100644
--- a/src/utils/FieldSuggestionParser.ts
+++ b/src/utils/FieldSuggestionParser.ts
@@ -1,3 +1,5 @@
+import { parsePipeKeyValue, splitPipeParts } from "./pipeSyntax";
+
 export interface FieldFilter {
 	folder?: string;
 	tags?: string[];
@@ -23,20 +25,17 @@ export class FieldSuggestionParser {
 		fieldName: string;
 		filters: FieldFilter;
 	} {
-		const parts = input.split("|").map((p) => p.trim());
+		const parts = splitPipeParts(input).map((p) => p.trim());
 		const fieldName = parts[0];
 		const filters: FieldFilter = {};
 
 		for (let i = 1; i < parts.length; i++) {
 			const filterPart = parts[i];
-			const colonIndex = filterPart.indexOf(":");
-
-			if (colonIndex === -1) {
-				continue; // Skip invalid filter format
-			}
+			const parsed = parsePipeKeyValue(filterPart);
+			if (!parsed) continue; // Skip invalid filter format
 
-			const filterType = filterPart.substring(0, colonIndex).trim();
-			const filterValue = filterPart.substring(colonIndex + 1).trim();
+			const filterType = parsed.key;
+			const filterValue = parsed.value;
 
 			switch (filterType) {
 				case "folder":
@@ -94,4 +93,4 @@ export class FieldSuggestionParser {
 
 		return { fieldName, filters };
 	}
-}
\ No newline at end of file
+}
diff --git a/src/utils/pipeSyntax.ts b/src/utils/pipeSyntax.ts
new file mode 100644
index 00000000..07fe1f22
--- /dev/null
+++ b/src/utils/pipeSyntax.ts
@@ -0,0 +1,23 @@
+export function splitPipeParts(input: string): string[] {
+	// `String.prototype.split` preserves empty segments, including trailing ones.
+	return input.split("|");
+}
+
+export function stripLeadingPipe(input: string): string {
+	if (!input.startsWith("|")) return input;
+	return input.slice(1);
+}
+
+export function parsePipeKeyValue(
+	part: string,
+): { key: string; value: string } | null {
+	const colonIndex = part.indexOf(":");
+	if (colonIndex === -1) return null;
+
+	const key = part.slice(0, colonIndex).trim().toLowerCase();
+	if (!key) return null;
+
+	const value = part.slice(colonIndex + 1).trim();
+	return { key, value };
+}
+
diff --git a/src/utils/valueSyntax.ts b/src/utils/valueSyntax.ts
index 4fe83be4..e0d614c1 100644
--- a/src/utils/valueSyntax.ts
+++ b/src/utils/valueSyntax.ts
@@ -1,3 +1,5 @@
+import { parsePipeKeyValue, splitPipeParts, stripLeadingPipe } from "./pipeSyntax";
+
 // Internal-only delimiter for scoping labeled VALUE lists. Unlikely to appear in user input.
 export const VALUE_LABEL_KEY_DELIMITER = "\u001F";
 
@@ -92,9 +94,9 @@ function parseBoolean(value?: string): boolean {
 function hasRecognizedOption(part: string): boolean {
 	const trimmed = part.trim();
 	if (!trimmed) return false;
-	if (!trimmed.includes(":")) return false;
-	const key = trimmed.split(":", 1)[0]?.trim().toLowerCase();
-	return !!key && VALUE_OPTION_KEYS.has(key);
+	const parsed = parsePipeKeyValue(trimmed);
+	if (!parsed) return false;
+	return VALUE_OPTION_KEYS.has(parsed.key);
 }
 
 function parseOptions(optionParts: string[], hasOptions: boolean): ParsedOptions {
@@ -137,10 +139,9 @@ function parseOptions(optionParts: string[], hasOptions: boolean): ParsedOptions
 			continue;
 		}
 
-		const colonIndex = trimmed.indexOf(":");
-		if (colonIndex === -1) continue;
-		const key = trimmed.slice(0, colonIndex).trim().toLowerCase();
-		const value = trimmed.slice(colonIndex + 1).trim();
+		const parsed = parsePipeKeyValue(trimmed);
+		if (!parsed) continue;
+		const { key, value } = parsed;
 		if (!VALUE_OPTION_KEYS.has(key)) continue;
 
 		switch (key) {
@@ -202,7 +203,7 @@ function resolveInputType(
 export function parseValueToken(raw: string): ParsedValueToken | null {
 	if (!raw) return null;
 
-	const parts = raw.split("|");
+	const parts = splitPipeParts(raw);
 	const variablePart = (parts.shift() ?? "").trim();
 	if (!variablePart) return null;
 
@@ -252,11 +253,8 @@ export function parseAnonymousValueOptions(
 	defaultValue: string;
 	inputTypeOverride?: ValueInputType;
 } {
-	const normalized = rawOptions.startsWith("|")
-		? rawOptions.slice(1)
-		: rawOptions;
-	const parts = normalized
-		.split("|")
+	const normalized = stripLeadingPipe(rawOptions);
+	const parts = splitPipeParts(normalized)
 		.map((part) => part.trim())
 		.filter(Boolean);
 

From ab352bee2ea8774621ea885119a161abaf10985f Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Fri, 6 Feb 2026 23:30:12 +0100
Subject: [PATCH 3/5] feat(format): add case:slug and smart casing

---
 docs/docs/FormatSyntax.md  |  2 +-
 src/utils/caseTransform.ts | 91 +++++++++++++++++++++++++++++++-------
 2 files changed, 77 insertions(+), 16 deletions(-)

diff --git a/docs/docs/FormatSyntax.md b/docs/docs/FormatSyntax.md
index 5fcaf151..b2f2112e 100644
--- a/docs/docs/FormatSyntax.md
+++ b/docs/docs/FormatSyntax.md
@@ -14,7 +14,7 @@ title: Format syntax
 | `{{VALUE:<variable name>\|<default>}}`        | Same as above, but with a default value. For single-value prompts (e.g., `{{VALUE:name\|Anonymous}}`), the default is pre-populated in the input field - press Enter to accept or clear/edit it. For multi-value suggesters without `\|custom`, you must select one of the provided options (no default applies). If you combine keyed options like `\|label:`, `\|default:`, `\|type:`, or `\|case:`, shorthand defaults like `\|Anonymous` are ignored; use `\|default:Anonymous` instead. |
 | `{{VALUE:<variable name>\|default:<value>}}`        | Option-form default value, required when combining with other options like `\|label:`. Example: `{{VALUE:title\|label:Snake case\|default:My_Title}}`. |
 | `{{VALUE\|type:multiline}}` / `{{VALUE:<variable>\|type:multiline}}` | Forces a multi-line input prompt/textarea for that VALUE token. Only supported for single-value prompts (no comma options / `\|custom`). Overrides the global "Use Multi-line Input Prompt" setting. If `\|type:` is present, shorthand defaults like `\|Some value` are ignored; use `\|default:` instead. |
-| `{{VALUE\|case:<style>}}` / `{{NAME\|case:<style>}}` / `{{VALUE:<variable>\|case:<style>}}` | Transforms the resolved value into a casing style. Supported: `kebab`, `snake`, `camel`, `pascal`, `title`, `lower`, `upper`. Example: `{{VALUE:title\|case:kebab}}` outputs `my-new-blog` when the input is `My New Blog`. |
+| `{{VALUE\|case:<style>}}` / `{{NAME\|case:<style>}}` / `{{VALUE:<variable>\|case:<style>}}` | Transforms the resolved value into a casing style. Supported: `kebab`, `snake`, `camel`, `pascal`, `title`, `lower`, `upper`, `slug`. Example: `{{VALUE:title\|case:kebab}}` outputs `my-new-blog` when the input is `My New Blog`. Filename-safe slug example: `{{DATE:YYYY-MM-DD}}-{{VALUE:title\|case:slug}}.md`. |
 | `{{VALUE:<options>\|custom}}`        | Allows you to type custom values in addition to selecting from the provided options. Example: `{{VALUE:Red,Green,Blue\|custom}}` will suggest Red, Green, and Blue, but also allows you to type any other value like "Purple". This is useful when you have common options but want flexibility for edge cases. **Note:** You cannot combine `\|custom` with a shorthand default value - use `\|default:` if you need both. |
 | `{{LINKCURRENT}}`                          | A link to the file from which the template or capture was triggered (`[[link]]` format). When the append-link setting is set to **Enabled (skip if no active file)**, this token resolves to an empty string instead of throwing an error if no note is focused. |
 | `{{FILENAMECURRENT}}`                      | The basename (without extension) of the file from which the template or capture was triggered. Honors the same **required/optional** behavior as `{{LINKCURRENT}}` - when optional and no active file exists, resolves to an empty string. |
diff --git a/src/utils/caseTransform.ts b/src/utils/caseTransform.ts
index 522c5d01..064b18dc 100644
--- a/src/utils/caseTransform.ts
+++ b/src/utils/caseTransform.ts
@@ -1,3 +1,5 @@
+import { isReservedWindowsDeviceName } from "./pathValidation";
+
 export type CaseStyle =
 	| "kebab"
 	| "snake"
@@ -5,7 +7,8 @@ export type CaseStyle =
 	| "pascal"
 	| "title"
 	| "lower"
-	| "upper";
+	| "upper"
+	| "slug";
 
 function normalizeStyle(style?: string): CaseStyle | null {
 	if (!style) return null;
@@ -18,6 +21,7 @@ function normalizeStyle(style?: string): CaseStyle | null {
 		case "title":
 		case "lower":
 		case "upper":
+		case "slug":
 			return normalized;
 		default:
 			return null;
@@ -30,20 +34,51 @@ function upperFirstLowerRest(word: string): string {
 	return lower.slice(0, 1).toUpperCase() + lower.slice(1);
 }
 
-function splitWords(input: string): string[] {
-	let s = input;
+function isAcronym(word: string): boolean {
+	// Contains letters, includes uppercase, and includes no lowercase.
+	if (!/\p{L}/u.test(word)) return false;
+	return /\p{Lu}/u.test(word) && !/\p{Ll}/u.test(word);
+}
+
+function isMixedCase(word: string): boolean {
+	return /\p{Lu}/u.test(word) && /\p{Ll}/u.test(word);
+}
+
+function isLowerLeadingBrandToken(word: string): boolean {
+	// Brand-case heuristics: keep tokens like iOS/iPhone/eBay when they lead with lowercase.
+	return /^\p{Ll}/u.test(word) && isMixedCase(word);
+}
+
+function tokenizeSegment(segment: string): string[] {
+	if (!segment) return [];
+
+	// Special-case iOS-like brand tokens: keep them intact.
+	// Example: "iOS" -> ["iOS"], "iOS17" -> ["iOS", "17"].
+	{
+		const match = segment.match(/^([\p{Ll}][\p{Lu}]{2,})([\p{N}]+)?$/u);
+		if (match) {
+			const out = [match[1]];
+			if (match[2]) out.push(match[2]);
+			return out;
+		}
+	}
+
+	// Preserve one-letter brand-case like "iPhone" or "eBay" as a single token.
+	if (/^[\p{Ll}][\p{Lu}][\p{Ll}]+(?:[\p{Lu}][\p{Ll}]+)*$/u.test(segment)) {
+		return [segment];
+	}
 
-	// Handle common camel/pascal boundaries (including acronyms like XMLHttp -> XML Http).
+	let s = segment;
+
+	// Split typical acronym+word boundaries (XMLHttp -> XML Http).
 	s = s.replace(/([\p{Lu}]+)([\p{Lu}][\p{Ll}])/gu, "$1 $2");
+	// Split lower/digit -> upper boundaries (myNew -> my New).
 	s = s.replace(/([\p{Ll}\p{N}])([\p{Lu}])/gu, "$1 $2");
 
 	// Split letter <-> number boundaries (Blog2Post -> Blog 2 Post).
 	s = s.replace(/([\p{L}])([\p{N}])/gu, "$1 $2");
 	s = s.replace(/([\p{N}])([\p{L}])/gu, "$1 $2");
 
-	// Treat any non-letter/non-number as separators. Keep combining marks with letters.
-	s = s.replace(/[^\p{L}\p{N}\p{M}]+/gu, " ");
-
 	return s
 		.trim()
 		.split(/\s+/u)
@@ -51,6 +86,12 @@ function splitWords(input: string): string[] {
 		.filter(Boolean);
 }
 
+function tokenizeWords(input: string): string[] {
+	// Treat any non-letter/non-number/non-mark as separators.
+	const segments = input.split(/[^\p{L}\p{N}\p{M}]+/gu).filter(Boolean);
+	return segments.flatMap(tokenizeSegment).filter(Boolean);
+}
+
 export function transformCase(input: string, style?: string): string {
 	const normalized = normalizeStyle(style);
 	if (!normalized) return input;
@@ -58,7 +99,7 @@ export function transformCase(input: string, style?: string): string {
 	if (normalized === "lower") return input.toLowerCase();
 	if (normalized === "upper") return input.toUpperCase();
 
-	const words = splitWords(input);
+	const words = tokenizeWords(input);
 	if (words.length === 0) return "";
 
 	switch (normalized) {
@@ -68,17 +109,37 @@ export function transformCase(input: string, style?: string): string {
 			return words.map((w) => w.toLowerCase()).join("_");
 		case "camel": {
 			const [first, ...rest] = words;
-			return [
-				first?.toLowerCase() ?? "",
-				...rest.map((w) => upperFirstLowerRest(w)),
-			].join("");
+			const firstOut = first
+				? isLowerLeadingBrandToken(first)
+					? first
+					: first.toLowerCase()
+				: "";
+			const restOut = rest.map((word) => {
+				if (isAcronym(word) || isMixedCase(word)) return word;
+				return upperFirstLowerRest(word);
+			});
+			return [firstOut, ...restOut].join("");
 		}
 		case "pascal":
-			return words.map((w) => upperFirstLowerRest(w)).join("");
+			return words
+				.map((word) => {
+					if (isAcronym(word) || isMixedCase(word)) return word;
+					return upperFirstLowerRest(word);
+				})
+				.join("");
 		case "title":
-			return words.map((w) => upperFirstLowerRest(w)).join(" ");
+			return words
+				.map((word) => {
+					if (isAcronym(word) || isMixedCase(word)) return word;
+					return upperFirstLowerRest(word);
+				})
+				.join(" ");
+		case "slug": {
+			const slug = words.map((w) => w.toLowerCase()).join("-");
+			if (isReservedWindowsDeviceName(slug)) return `${slug}-`;
+			return slug;
+		}
 		default:
 			return input;
 	}
 }
-

From 6100e88a2d610a8b707fbc6cd596f03d7d39d97e Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Fri, 6 Feb 2026 23:30:15 +0100
Subject: [PATCH 4/5] feat(ui): suggest case styles for format syntax

---
 src/gui/suggesters/formatSyntaxSuggester.ts | 30 ++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/gui/suggesters/formatSyntaxSuggester.ts b/src/gui/suggesters/formatSyntaxSuggester.ts
index 82f5bb60..a4740a91 100644
--- a/src/gui/suggesters/formatSyntaxSuggester.ts
+++ b/src/gui/suggesters/formatSyntaxSuggester.ts
@@ -196,7 +196,35 @@ export class FormatSyntaxSuggester extends TextInputSuggest<string> {
 			return [];
 		}
 
-		// If the segment already contains a colon we consider the token "open" for user parameters → no more format suggestions
+		// Special-case: suggest casing styles when typing `|case:` inside VALUE/NAME tokens.
+		{
+			const caseMatch = inputSegment.match(
+				/^\{\{(?:VALUE|NAME)[^\n\r}]*\|case:([a-z-]*)$/i,
+			);
+			if (caseMatch) {
+				const fragment = caseMatch[1] ?? "";
+				const normalizedFragment = fragment.toLowerCase();
+				const styles = [
+					"kebab",
+					"snake",
+					"camel",
+					"pascal",
+					"title",
+					"lower",
+					"upper",
+					"slug",
+				];
+
+				this.lastInput = fragment;
+				this.lastInputStart = cursorPosition - fragment.length;
+
+				return styles.filter((style) =>
+					style.startsWith(normalizedFragment),
+				);
+			}
+		}
+
+		// If the segment already contains a colon we consider the token "open" for user parameters → no more format suggestions.
 		if (inputSegment.includes(":")) {
 			return [];
 		}

From 1bdb748919f462f315ba5819080c69ccc1a6ae5e Mon Sep 17 00:00:00 2001
From: Christian Bager Bach Houmann <christian@bagerbach.com>
Date: Fri, 6 Feb 2026 23:30:28 +0100
Subject: [PATCH 5/5] test: cover slug/smart casing and case suggestions

---
 src/formatters/formatter-case.test.ts         |   6 +-
 .../formatSyntaxSuggester.case.test.ts        | 106 ++++++++++++++++++
 src/utils/caseTransform.test.ts               |  35 ++++++
 tests/obsidian-stub.ts                        |  10 ++
 4 files changed, 154 insertions(+), 3 deletions(-)
 create mode 100644 src/gui/suggesters/formatSyntaxSuggester.case.test.ts
 create mode 100644 src/utils/caseTransform.test.ts

diff --git a/src/formatters/formatter-case.test.ts b/src/formatters/formatter-case.test.ts
index 5ca8dbed..71742326 100644
--- a/src/formatters/formatter-case.test.ts
+++ b/src/formatters/formatter-case.test.ts
@@ -122,13 +122,13 @@ describe("Formatter case: pipe option", () => {
 		expect(result).toBe("a=My New Blog b=my-new-blog c=MY NEW BLOG");
 	});
 
-	it("supports snake/camel/pascal/title/lower transforms", async () => {
+	it("supports snake/camel/pascal/title/lower/slug transforms", async () => {
 		formatter.setValueResponse("my new blog");
 		const result = await formatter.testFormat(
-			"snake={{VALUE|case:snake}} camel={{VALUE|case:camel}} pascal={{VALUE|case:pascal}} title={{VALUE|case:title}} lower={{VALUE|case:lower}}",
+			"snake={{VALUE|case:snake}} camel={{VALUE|case:camel}} pascal={{VALUE|case:pascal}} title={{VALUE|case:title}} lower={{VALUE|case:lower}} slug={{VALUE|case:slug}}",
 		);
 		expect(result).toBe(
-			"snake=my_new_blog camel=myNewBlog pascal=MyNewBlog title=My New Blog lower=my new blog",
+			"snake=my_new_blog camel=myNewBlog pascal=MyNewBlog title=My New Blog lower=my new blog slug=my-new-blog",
 		);
 	});
 
diff --git a/src/gui/suggesters/formatSyntaxSuggester.case.test.ts b/src/gui/suggesters/formatSyntaxSuggester.case.test.ts
new file mode 100644
index 00000000..dc0d8533
--- /dev/null
+++ b/src/gui/suggesters/formatSyntaxSuggester.case.test.ts
@@ -0,0 +1,106 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { FormatSyntaxSuggester } from "./formatSyntaxSuggester";
+
+function ensureObsidianDomPolyfills(): void {
+	(globalThis as any).createDiv ??= (cls?: string) => {
+		const div = document.createElement("div");
+		if (cls) div.className = cls;
+		return div;
+	};
+
+	const proto = HTMLElement.prototype as any;
+
+	proto.createDiv ??= function (arg?: string | { cls?: string }) {
+		const div = document.createElement("div");
+		if (typeof arg === "string") div.className = arg;
+		else if (arg && typeof arg === "object" && typeof arg.cls === "string")
+			div.className = arg.cls;
+		this.appendChild(div);
+		return div;
+	};
+
+	proto.empty ??= function () {
+		this.replaceChildren();
+		return this;
+	};
+
+	// Obsidian adds delegated event helpers; tests don't need behavior here.
+	proto.on ??= function () {
+		return this;
+	};
+
+	proto.detach ??= function () {
+		this.remove();
+	};
+
+	proto.addClass ??= function (...classes: string[]) {
+		this.classList.add(...classes);
+		return this;
+	};
+
+	proto.removeClass ??= function (...classes: string[]) {
+		this.classList.remove(...classes);
+		return this;
+	};
+
+	proto.setAttr ??= function (name: string, value: string) {
+		this.setAttribute(name, value);
+		return this;
+	};
+}
+
+describe("FormatSyntaxSuggester case style suggestions", () => {
+	beforeEach(() => {
+		ensureObsidianDomPolyfills();
+	});
+
+	it("suggests kebab when typing a |case: prefix", async () => {
+		const app = {
+			dom: { appContainerEl: document.body },
+			keymap: { pushScope: () => {}, popScope: () => {} },
+		} as any;
+		const plugin = {
+			settings: { choices: [], globalVariables: {} },
+			getTemplateFiles: () => [],
+		} as any;
+
+		const inputEl = document.createElement("input");
+		inputEl.value = "{{VALUE:title|case:k";
+		inputEl.selectionStart = inputEl.value.length;
+		inputEl.selectionEnd = inputEl.value.length;
+
+		const suggester = new FormatSyntaxSuggester(app, inputEl, plugin);
+		const suggestions = await suggester.getSuggestions(inputEl.value);
+		expect(suggestions).toEqual(["kebab"]);
+		suggester.destroy();
+	});
+
+	it("suggests all styles (including slug) when case fragment is empty", async () => {
+		const app = {
+			dom: { appContainerEl: document.body },
+			keymap: { pushScope: () => {}, popScope: () => {} },
+		} as any;
+		const plugin = {
+			settings: { choices: [], globalVariables: {} },
+			getTemplateFiles: () => [],
+		} as any;
+
+		const inputEl = document.createElement("input");
+		inputEl.value = "{{VALUE:title|case:";
+		inputEl.selectionStart = inputEl.value.length;
+		inputEl.selectionEnd = inputEl.value.length;
+
+		const suggester = new FormatSyntaxSuggester(app, inputEl, plugin);
+		const suggestions = await suggester.getSuggestions(inputEl.value);
+		expect(suggestions).toContain("slug");
+		expect(suggestions).toContain("kebab");
+		expect(suggestions).toContain("snake");
+		expect(suggestions).toContain("camel");
+		expect(suggestions).toContain("pascal");
+		expect(suggestions).toContain("title");
+		expect(suggestions).toContain("lower");
+		expect(suggestions).toContain("upper");
+		suggester.destroy();
+	});
+});
+
diff --git a/src/utils/caseTransform.test.ts b/src/utils/caseTransform.test.ts
new file mode 100644
index 00000000..c1441d4c
--- /dev/null
+++ b/src/utils/caseTransform.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { transformCase } from "./caseTransform";
+
+describe("transformCase", () => {
+	it("supports basic transforms", () => {
+		const input = "My New Blog";
+		expect(transformCase(input, "kebab")).toBe("my-new-blog");
+		expect(transformCase(input, "snake")).toBe("my_new_blog");
+		expect(transformCase(input, "camel")).toBe("myNewBlog");
+		expect(transformCase(input, "pascal")).toBe("MyNewBlog");
+		expect(transformCase(input, "title")).toBe("My New Blog");
+		expect(transformCase(input, "lower")).toBe("my new blog");
+		expect(transformCase(input, "upper")).toBe("MY NEW BLOG");
+	});
+
+	it("handles acronyms with smart camel and preserves them for pascal/title", () => {
+		expect(transformCase("API Key", "camel")).toBe("apiKey");
+		expect(transformCase("My API Key", "camel")).toBe("myAPIKey");
+		expect(transformCase("API Key", "pascal")).toBe("APIKey");
+		expect(transformCase("API Key", "title")).toBe("API Key");
+	});
+
+	it("preserves mixed-case brand tokens like iOS", () => {
+		expect(transformCase("iOS App", "camel")).toBe("iOSApp");
+		expect(transformCase("iOS App", "pascal")).toBe("iOSApp");
+		expect(transformCase("iOS App", "title")).toBe("iOS App");
+	});
+
+	it("supports slug and avoids reserved Windows device names", () => {
+		expect(transformCase("My New Blog", "slug")).toBe("my-new-blog");
+		expect(transformCase("CON", "slug")).toBe("con-");
+		expect(transformCase("A/B*C?", "slug")).toBe("a-b-c");
+	});
+});
+
diff --git a/tests/obsidian-stub.ts b/tests/obsidian-stub.ts
index 0cc52980..f9d8a3b8 100644
--- a/tests/obsidian-stub.ts
+++ b/tests/obsidian-stub.ts
@@ -511,6 +511,15 @@ export function normalizePath(p: string): string {
   return p.replace(/\\/g, '/');
 }
 
+// Minimal debounce for tests: execute immediately.
+export function debounce<T extends (...args: any[]) => any>(
+  fn: T,
+  _wait: number,
+  _resetTimer?: boolean,
+): T {
+  return fn;
+}
+
 // Default export for compatibility
 export default {
   App,
@@ -534,4 +543,5 @@ export default {
   Notice,
   moment,
   normalizePath,
+  debounce,
 };