@analogjs/platform 3.0.0-alpha.9 → 3.0.0-alpha.90

package/src/lib/inject-server-fn-ids.js

@@ -0,0 +1,94 @@
+import { deriveServerFnId } from "./server-fn-id.js";
+import { parseSync } from "oxc-parser";
+import MagicString from "magic-string";
+//#region packages/platform/src/lib/inject-server-fn-ids.ts
+var SERVER_FN_SOURCE = "@analogjs/router/server";
+/**
+* Server/SSR-build transform: injects the derived `id` into each
+* `export const NAME = serverFn(config, handler)` so the function registers
+* under the same opaque id the client proxy dispatches to. Unlike the client
+* scrub this keeps the handler and every other statement intact — it only edits
+* the config object — so the server module still runs the real implementation.
+*
+* Returns `null` when the module defines no server function.
+*/
+function injectServerFnIds(code, fileId) {
+	if (!code.includes("serverFn")) return null;
+	const { program } = parseSync(fileId, code);
+	const body = program.body;
+	const serverFnLocalNames = collectServerFnLocalNames(body);
+	const magic = new MagicString(code);
+	const ids = [];
+	for (const node of body) {
+		if (node.type !== "ExportNamedDeclaration" || node.declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of node.declaration.declarations) {
+			if (declarator.id?.type !== "Identifier" || declarator.init?.type !== "CallExpression" || declarator.init.callee?.type !== "Identifier" || !serverFnLocalNames.has(declarator.init.callee.name)) continue;
+			const name = declarator.id.name;
+			const id = deriveServerFnId(fileId, name);
+			ids.push({
+				name,
+				id
+			});
+			const args = declarator.init.arguments ?? [];
+			const arg0 = args[0];
+			const idProp = `id: ${JSON.stringify(id)}`;
+			if (arg0?.type === "ObjectExpression") {
+				assertMethodInputCompatible(arg0, name, fileId);
+				injectId(magic, arg0, id);
+			} else if (isFunctionNode(arg0)) magic.appendLeft(arg0.start, `{ ${idProp} }, `);
+			else if (arg0 && args.length >= 2) {
+				magic.appendLeft(arg0.start, `{ ${idProp}, input: `);
+				magic.appendRight(arg0.end, ` }`);
+			} else throw new Error(`[analog] serverFn "${name}" in ${fileId} must be called as serverFn(handler), serverFn(schema, handler), or serverFn(config, handler).`);
+		}
+	}
+	if (ids.length === 0) return null;
+	return {
+		code: magic.toString(),
+		ids
+	};
+}
+/**
+* Insert (or replace) `id: "<derived>"` in the config object. Authors do not
+* supply an id; a stray one is overwritten so the route is always the derived,
+* non-enumerable digest — never an author-controlled value.
+*/
+function injectId(magic, configArg, id) {
+	const existing = (configArg.properties ?? []).find((prop) => prop.type === "Property" && (prop.key?.type === "Identifier" ? prop.key.name : prop.key?.value) === "id");
+	if (existing) {
+		magic.overwrite(existing.value.start, existing.value.end, JSON.stringify(id));
+		return;
+	}
+	magic.appendRight(configArg.start + 1, ` id: ${JSON.stringify(id)},`);
+}
+/**
+* Reject `method: 'GET'` alongside an `input` schema at build time: GET carries
+* no body, so a GET function can never receive validated input.
+*/
+function assertMethodInputCompatible(configArg, name, fileId) {
+	let method;
+	let hasInput = false;
+	for (const prop of configArg.properties ?? []) {
+		if (prop.type !== "Property") continue;
+		const key = prop.key?.type === "Identifier" ? prop.key.name : prop.key?.value;
+		if (key === "method" && prop.value?.type === "Literal") method = prop.value.value;
+		else if (key === "input") hasInput = true;
+	}
+	if (method === "GET" && hasInput) throw new Error(`[analog] serverFn "${name}" in ${fileId} declares method: 'GET' with an input schema; GET carries no body. Use POST (the default when input is present) or drop the input.`);
+}
+function isFunctionNode(node) {
+	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+function collectServerFnLocalNames(body) {
+	const names = /* @__PURE__ */ new Set();
+	for (const node of body) {
+		if (node.type !== "ImportDeclaration" || node.source?.value !== SERVER_FN_SOURCE) continue;
+		for (const spec of node.specifiers ?? []) if (spec.type === "ImportSpecifier" && spec.imported?.name === "serverFn") names.add(spec.local.name);
+	}
+	if (names.size === 0) names.add("serverFn");
+	return names;
+}
+//#endregion
+export { injectServerFnIds };
+
+//# sourceMappingURL=inject-server-fn-ids.js.map

package/src/lib/inject-server-fn-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-server-fn-ids.js","names":[],"sources":["../../../src/lib/inject-server-fn-ids.ts"],"sourcesContent":["import MagicString from 'magic-string';\nimport { parseSync } from 'oxc-parser';\n\nimport { deriveServerFnId } from './server-fn-id.js';\n\nconst SERVER_FN_SOURCE = '@analogjs/router/server';\n\nexport interface InjectServerFnIdsResult {\n  code: string;\n  ids: { name: string; id: string }[];\n}\n\n/**\n * Server/SSR-build transform: injects the derived `id` into each\n * `export const NAME = serverFn(config, handler)` so the function registers\n * under the same opaque id the client proxy dispatches to. Unlike the client\n * scrub this keeps the handler and every other statement intact — it only edits\n * the config object — so the server module still runs the real implementation.\n *\n * Returns `null` when the module defines no server function.\n */\nexport function injectServerFnIds(\n  code: string,\n  fileId: string,\n): InjectServerFnIdsResult | null {\n  if (!code.includes('serverFn')) {\n    return null;\n  }\n\n  const { program } = parseSync(fileId, code);\n  const body = (program as { body: any[] }).body;\n  const serverFnLocalNames = collectServerFnLocalNames(body);\n\n  const magic = new MagicString(code);\n  const ids: { name: string; id: string }[] = [];\n\n  for (const node of body) {\n    if (\n      node.type !== 'ExportNamedDeclaration' ||\n      node.declaration?.type !== 'VariableDeclaration'\n    ) {\n      continue;\n    }\n    for (const declarator of node.declaration.declarations) {\n      if (\n        declarator.id?.type !== 'Identifier' ||\n        declarator.init?.type !== 'CallExpression' ||\n        declarator.init.callee?.type !== 'Identifier' ||\n        !serverFnLocalNames.has(declarator.init.callee.name)\n      ) {\n        continue;\n      }\n\n      const name = declarator.id.name;\n      const id = deriveServerFnId(fileId, name);\n      ids.push({ name, id });\n\n      const args = declarator.init.arguments ?? [];\n      const arg0 = args[0];\n      const idProp = `id: ${JSON.stringify(id)}`;\n\n      if (arg0?.type === 'ObjectExpression') {\n        // serverFn({ … }, handler) — inject the id into the config object.\n        assertMethodInputCompatible(arg0, name, fileId);\n        injectId(magic, arg0, id);\n      } else if (isFunctionNode(arg0)) {\n        // serverFn(handler) — synthesize a config: `{ id }, handler`.\n        magic.appendLeft(arg0.start, `{ ${idProp} }, `);\n      } else if (arg0 && args.length >= 2) {\n        // serverFn(schema, handler) — wrap the schema into `{ id, input: <schema> }`.\n        magic.appendLeft(arg0.start, `{ ${idProp}, input: `);\n        magic.appendRight(arg0.end, ` }`);\n      } else {\n        throw new Error(\n          `[analog] serverFn \"${name}\" in ${fileId} must be called as serverFn(handler), serverFn(schema, handler), or serverFn(config, handler).`,\n        );\n      }\n    }\n  }\n\n  if (ids.length === 0) {\n    return null;\n  }\n\n  return { code: magic.toString(), ids };\n}\n\n/**\n * Insert (or replace) `id: \"<derived>\"` in the config object. Authors do not\n * supply an id; a stray one is overwritten so the route is always the derived,\n * non-enumerable digest — never an author-controlled value.\n */\nfunction injectId(magic: MagicString, configArg: any, id: string): void {\n  const existing = (configArg.properties ?? []).find(\n    (prop: any) =>\n      prop.type === 'Property' &&\n      (prop.key?.type === 'Identifier' ? prop.key.name : prop.key?.value) ===\n        'id',\n  );\n\n  if (existing) {\n    magic.overwrite(\n      existing.value.start,\n      existing.value.end,\n      JSON.stringify(id),\n    );\n    return;\n  }\n\n  // Insert as the first property, right after the opening brace.\n  magic.appendRight(configArg.start + 1, ` id: ${JSON.stringify(id)},`);\n}\n\n/**\n * Reject `method: 'GET'` alongside an `input` schema at build time: GET carries\n * no body, so a GET function can never receive validated input.\n */\nfunction assertMethodInputCompatible(\n  configArg: any,\n  name: string,\n  fileId: string,\n): void {\n  let method: string | undefined;\n  let hasInput = false;\n  for (const prop of configArg.properties ?? []) {\n    if (prop.type !== 'Property') continue;\n    const key =\n      prop.key?.type === 'Identifier' ? prop.key.name : prop.key?.value;\n    if (key === 'method' && prop.value?.type === 'Literal') {\n      method = prop.value.value;\n    } else if (key === 'input') {\n      hasInput = true;\n    }\n  }\n  if (method === 'GET' && hasInput) {\n    throw new Error(\n      `[analog] serverFn \"${name}\" in ${fileId} declares method: 'GET' with an input schema; GET carries no body. Use POST (the default when input is present) or drop the input.`,\n    );\n  }\n}\n\nfunction isFunctionNode(node: any): boolean {\n  return (\n    node?.type === 'ArrowFunctionExpression' ||\n    node?.type === 'FunctionExpression'\n  );\n}\n\nfunction collectServerFnLocalNames(body: any[]): Set<string> {\n  const names = new Set<string>();\n  for (const node of body) {\n    if (\n      node.type !== 'ImportDeclaration' ||\n      node.source?.value !== SERVER_FN_SOURCE\n    ) {\n      continue;\n    }\n    for (const spec of node.specifiers ?? []) {\n      if (\n        spec.type === 'ImportSpecifier' &&\n        spec.imported?.name === 'serverFn'\n      ) {\n        names.add(spec.local.name);\n      }\n    }\n  }\n  if (names.size === 0) {\n    names.add('serverFn');\n  }\n  return names;\n}\n"],"mappings":"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"}

package/src/lib/json-ld-manifest-plugin.d.ts

@@ -0,0 +1,41 @@
+import { type JsonLdObject } from "./route-manifest.js";
+export type JsonLdModuleManifestEntry = {
+	kind: "module";
+	routePath: string;
+	sourceFile: string;
+	importAlias: string;
+};
+export type JsonLdContentManifestEntry = {
+	kind: "content";
+	routePath: string;
+	sourceFile: string;
+	jsonLd: JsonLdObject[];
+};
+export type JsonLdManifestEntry = JsonLdModuleManifestEntry | JsonLdContentManifestEntry;
+/**
+* Heuristic detector for JSON-LD exports in route modules.
+*
+* This is intentionally regex-based for speed during file scanning.
+* It reliably detects these direct export patterns:
+*
+* - `export const routeJsonLd = ...`
+* - `export const routeMeta = { ..., jsonLd: ... }`
+* - `export const routeJsonLd = (route) => ...` (function form)
+*
+* Known limitations (not detected):
+*
+* - re-exports: `export { routeJsonLd } from './data'`
+* - aliased exports: `export { something as routeJsonLd }`
+* - default exports: `export default { jsonLd: ... }`
+* - indirect assignment: `const data = { jsonLd: ... }; export const routeMeta = data`
+*
+* Known false-positive risks:
+*
+* - comment text containing `export const routeJsonLd`
+* - unrelated `jsonLd` text appearing after `export const routeMeta`
+*
+* Prefer the supported direct export patterns listed above.
+*/
+export declare function detectJsonLdModuleExports(fileContent: string): boolean;
+export declare function extractMarkdownJsonLd(rawContent: string): JsonLdObject[];
+export declare function generateJsonLdManifestSource(entries: JsonLdManifestEntry[], outFile: string): string;

package/src/lib/json-ld-manifest-plugin.js

@@ -0,0 +1,84 @@
+import { normalizeJsonLd } from "./route-manifest.js";
+import { dirname, relative } from "node:path";
+import { normalizePath } from "vite";
+import fm from "front-matter";
+//#region packages/platform/src/lib/json-ld-manifest-plugin.ts
+/**
+* Heuristic detector for JSON-LD exports in route modules.
+*
+* This is intentionally regex-based for speed during file scanning.
+* It reliably detects these direct export patterns:
+*
+* - `export const routeJsonLd = ...`
+* - `export const routeMeta = { ..., jsonLd: ... }`
+* - `export const routeJsonLd = (route) => ...` (function form)
+*
+* Known limitations (not detected):
+*
+* - re-exports: `export { routeJsonLd } from './data'`
+* - aliased exports: `export { something as routeJsonLd }`
+* - default exports: `export default { jsonLd: ... }`
+* - indirect assignment: `const data = { jsonLd: ... }; export const routeMeta = data`
+*
+* Known false-positive risks:
+*
+* - comment text containing `export const routeJsonLd`
+* - unrelated `jsonLd` text appearing after `export const routeMeta`
+*
+* Prefer the supported direct export patterns listed above.
+*/
+function detectJsonLdModuleExports(fileContent) {
+	return /export\s+const\s+routeJsonLd\b/.test(fileContent) || /export\s+const\s+routeMeta\b[\s\S]*?\bjsonLd\b/.test(fileContent);
+}
+function extractMarkdownJsonLd(rawContent) {
+	const { attributes } = fm(rawContent);
+	return normalizeJsonLd(attributes["jsonLd"]);
+}
+function generateJsonLdManifestSource(entries, outFile) {
+	const lines = [];
+	const moduleEntries = entries.filter((entry) => entry.kind === "module");
+	lines.push("// This file is auto-generated by @analogjs/platform");
+	lines.push("// Do not edit manually");
+	lines.push("");
+	lines.push("import type { Graph, Thing, WithContext } from 'schema-dts';");
+	moduleEntries.forEach((entry) => {
+		lines.push(`import * as ${entry.importAlias} from '${toImportPath(outFile, entry.sourceFile)}';`);
+	});
+	lines.push("");
+	lines.push("export type AnalogJsonLdDocument = WithContext<Thing> | Graph | Array<WithContext<Thing>>;");
+	lines.push("export type GeneratedJsonLdManifestEntry = { routePath: string; sourceFile: string; kind: 'module' | 'content'; resolveJsonLd: () => AnalogJsonLdDocument[]; };");
+	lines.push("");
+	lines.push("function normalizeJsonLd(value: unknown): AnalogJsonLdDocument[] {");
+	lines.push("  if (Array.isArray(value)) {");
+	lines.push("    return value.filter((entry): entry is AnalogJsonLdDocument => typeof entry === 'object' && entry !== null && !Array.isArray(entry));");
+	lines.push("  }");
+	lines.push("");
+	lines.push("  return typeof value === 'object' && value !== null ? [value as AnalogJsonLdDocument] : [];");
+	lines.push("}");
+	lines.push("");
+	lines.push("function resolveModuleJsonLd(routeModule: unknown): AnalogJsonLdDocument[] {");
+	lines.push("  const typedRouteModule = routeModule as { routeJsonLd?: unknown; routeMeta?: { jsonLd?: unknown } };");
+	lines.push("  return normalizeJsonLd(typedRouteModule.routeMeta?.jsonLd ?? typedRouteModule.routeJsonLd);");
+	lines.push("}");
+	lines.push("");
+	lines.push("export const routeJsonLdManifest = new Map<string, GeneratedJsonLdManifestEntry>([");
+	entries.forEach((entry) => {
+		if (entry.kind === "module") {
+			lines.push(`  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'module', resolveJsonLd: () => resolveModuleJsonLd(${entry.importAlias}) }],`);
+			return;
+		}
+		lines.push(`  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'content', resolveJsonLd: () => ${JSON.stringify(entry.jsonLd)} }],`);
+	});
+	lines.push("]);");
+	lines.push("");
+	return lines.join("\n");
+}
+function toImportPath(outFile, sourceFile) {
+	const relativePath = normalizePath(relative(dirname(outFile), sourceFile.replace(/^\//, "").replace(/\.(ts|js|analog|ag)$/, "")));
+	if (relativePath.startsWith(".")) return relativePath;
+	return `./${relativePath}`;
+}
+//#endregion
+export { detectJsonLdModuleExports, extractMarkdownJsonLd, generateJsonLdManifestSource };
+
+//# sourceMappingURL=json-ld-manifest-plugin.js.map

package/src/lib/json-ld-manifest-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-ld-manifest-plugin.js","names":[],"sources":["../../../src/lib/json-ld-manifest-plugin.ts"],"sourcesContent":["import fm from 'front-matter';\nimport { normalizePath } from 'vite';\nimport { dirname, relative } from 'node:path';\n\nimport { normalizeJsonLd, type JsonLdObject } from './route-manifest.js';\n\nexport type JsonLdModuleManifestEntry = {\n  kind: 'module';\n  routePath: string;\n  sourceFile: string;\n  importAlias: string;\n};\n\nexport type JsonLdContentManifestEntry = {\n  kind: 'content';\n  routePath: string;\n  sourceFile: string;\n  jsonLd: JsonLdObject[];\n};\n\nexport type JsonLdManifestEntry =\n  | JsonLdModuleManifestEntry\n  | JsonLdContentManifestEntry;\n\n/**\n * Heuristic detector for JSON-LD exports in route modules.\n *\n * This is intentionally regex-based for speed during file scanning.\n * It reliably detects these direct export patterns:\n *\n * - `export const routeJsonLd = ...`\n * - `export const routeMeta = { ..., jsonLd: ... }`\n * - `export const routeJsonLd = (route) => ...` (function form)\n *\n * Known limitations (not detected):\n *\n * - re-exports: `export { routeJsonLd } from './data'`\n * - aliased exports: `export { something as routeJsonLd }`\n * - default exports: `export default { jsonLd: ... }`\n * - indirect assignment: `const data = { jsonLd: ... }; export const routeMeta = data`\n *\n * Known false-positive risks:\n *\n * - comment text containing `export const routeJsonLd`\n * - unrelated `jsonLd` text appearing after `export const routeMeta`\n *\n * Prefer the supported direct export patterns listed above.\n */\nexport function detectJsonLdModuleExports(fileContent: string): boolean {\n  return (\n    /export\\s+const\\s+routeJsonLd\\b/.test(fileContent) ||\n    /export\\s+const\\s+routeMeta\\b[\\s\\S]*?\\bjsonLd\\b/.test(fileContent)\n  );\n}\n\nexport function extractMarkdownJsonLd(rawContent: string): JsonLdObject[] {\n  const { attributes } = fm<Record<string, unknown>>(rawContent);\n  return normalizeJsonLd(attributes['jsonLd']);\n}\n\nexport function generateJsonLdManifestSource(\n  entries: JsonLdManifestEntry[],\n  outFile: string,\n): string {\n  const lines: string[] = [];\n  const moduleEntries = entries.filter(\n    (entry): entry is JsonLdModuleManifestEntry => entry.kind === 'module',\n  );\n\n  lines.push('// This file is auto-generated by @analogjs/platform');\n  lines.push('// Do not edit manually');\n  lines.push('');\n\n  lines.push(\"import type { Graph, Thing, WithContext } from 'schema-dts';\");\n\n  moduleEntries.forEach((entry) => {\n    lines.push(\n      `import * as ${entry.importAlias} from '${toImportPath(outFile, entry.sourceFile)}';`,\n    );\n  });\n\n  lines.push('');\n  lines.push(\n    'export type AnalogJsonLdDocument = WithContext<Thing> | Graph | Array<WithContext<Thing>>;',\n  );\n  lines.push(\n    \"export type GeneratedJsonLdManifestEntry = { routePath: string; sourceFile: string; kind: 'module' | 'content'; resolveJsonLd: () => AnalogJsonLdDocument[]; };\",\n  );\n  lines.push('');\n  lines.push(\n    'function normalizeJsonLd(value: unknown): AnalogJsonLdDocument[] {',\n  );\n  lines.push('  if (Array.isArray(value)) {');\n  lines.push(\n    \"    return value.filter((entry): entry is AnalogJsonLdDocument => typeof entry === 'object' && entry !== null && !Array.isArray(entry));\",\n  );\n  lines.push('  }');\n  lines.push('');\n  lines.push(\n    \"  return typeof value === 'object' && value !== null ? [value as AnalogJsonLdDocument] : [];\",\n  );\n  lines.push('}');\n  lines.push('');\n  lines.push(\n    'function resolveModuleJsonLd(routeModule: unknown): AnalogJsonLdDocument[] {',\n  );\n  lines.push(\n    '  const typedRouteModule = routeModule as { routeJsonLd?: unknown; routeMeta?: { jsonLd?: unknown } };',\n  );\n  lines.push(\n    // Match runtime precedence (mergeRouteJsonLdIntoRouteMeta in routes.ts):\n    // routeMeta.jsonLd wins over standalone routeJsonLd.\n    '  return normalizeJsonLd(typedRouteModule.routeMeta?.jsonLd ?? typedRouteModule.routeJsonLd);',\n  );\n  lines.push('}');\n  lines.push('');\n  lines.push(\n    'export const routeJsonLdManifest = new Map<string, GeneratedJsonLdManifestEntry>([',\n  );\n\n  entries.forEach((entry) => {\n    if (entry.kind === 'module') {\n      lines.push(\n        `  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'module', resolveJsonLd: () => resolveModuleJsonLd(${entry.importAlias}) }],`,\n      );\n      return;\n    }\n\n    lines.push(\n      `  ['${entry.routePath}', { routePath: '${entry.routePath}', sourceFile: '${entry.sourceFile}', kind: 'content', resolveJsonLd: () => ${JSON.stringify(entry.jsonLd)} }],`,\n    );\n  });\n\n  lines.push(']);');\n  lines.push('');\n\n  return lines.join('\\n');\n}\n\nfunction toImportPath(outFile: string, sourceFile: string): string {\n  // JSON-LD entries are emitted inside the same generated route module, so\n  // imports are always resolved relative to that single output file.\n  const fromDir = dirname(outFile);\n  const sourceNoExt = sourceFile\n    .replace(/^\\//, '')\n    .replace(/\\.(ts|js|analog|ag)$/, '');\n  const relativePath = normalizePath(relative(fromDir, sourceNoExt));\n\n  if (relativePath.startsWith('.')) {\n    return relativePath;\n  }\n\n  return `./${relativePath}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,0BAA0B,aAA8B;AACtE,QACE,iCAAiC,KAAK,YAAY,IAClD,iDAAiD,KAAK,YAAY;;AAItE,SAAgB,sBAAsB,YAAoC;CACxE,MAAM,EAAE,eAAe,GAA4B,WAAW;AAC9D,QAAO,gBAAgB,WAAW,UAAU;;AAG9C,SAAgB,6BACd,SACA,SACQ;CACR,MAAM,QAAkB,EAAE;CAC1B,MAAM,gBAAgB,QAAQ,QAC3B,UAA8C,MAAM,SAAS,SAC/D;AAED,OAAM,KAAK,uDAAuD;AAClE,OAAM,KAAK,0BAA0B;AACrC,OAAM,KAAK,GAAG;AAEd,OAAM,KAAK,+DAA+D;AAE1E,eAAc,SAAS,UAAU;AAC/B,QAAM,KACJ,eAAe,MAAM,YAAY,SAAS,aAAa,SAAS,MAAM,WAAW,CAAC,IACnF;GACD;AAEF,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,6FACD;AACD,OAAM,KACJ,kKACD;AACD,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,qEACD;AACD,OAAM,KAAK,gCAAgC;AAC3C,OAAM,KACJ,2IACD;AACD,OAAM,KAAK,MAAM;AACjB,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,+FACD;AACD,OAAM,KAAK,IAAI;AACf,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,+EACD;AACD,OAAM,KACJ,yGACD;AACD,OAAM,KAGJ,gGACD;AACD,OAAM,KAAK,IAAI;AACf,OAAM,KAAK,GAAG;AACd,OAAM,KACJ,qFACD;AAED,SAAQ,SAAS,UAAU;AACzB,MAAI,MAAM,SAAS,UAAU;AAC3B,SAAM,KACJ,OAAO,MAAM,UAAU,mBAAmB,MAAM,UAAU,kBAAkB,MAAM,WAAW,8DAA8D,MAAM,YAAY,OAC9K;AACD;;AAGF,QAAM,KACJ,OAAO,MAAM,UAAU,mBAAmB,MAAM,UAAU,kBAAkB,MAAM,WAAW,2CAA2C,KAAK,UAAU,MAAM,OAAO,CAAC,MACtK;GACD;AAEF,OAAM,KAAK,MAAM;AACjB,OAAM,KAAK,GAAG;AAEd,QAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,aAAa,SAAiB,YAA4B;CAOjE,MAAM,eAAe,cAAc,SAJnB,QAAQ,QAAQ,EACZ,WACjB,QAAQ,OAAO,GAAG,CAClB,QAAQ,wBAAwB,GAAG,CAC2B,CAAC;AAElE,KAAI,aAAa,WAAW,IAAI,CAC9B,QAAO;AAGT,QAAO,KAAK"}

package/src/lib/nitro/analog-nitro-plugin.d.ts

@@ -0,0 +1,18 @@
+import type { Nitro } from "nitro/types";
+import type { Plugin } from "vite";
+import type { Options } from "../options.js";
+/**
+* Analog's NitroModule. Plug it into the Vite plugin chain alongside
+* `nitro()` from `nitro/vite`; nitro/vite picks up the `.nitro` property
+* and runs `setup(nitro)` once the Nitro instance is ready.
+*/
+export declare function analogNitroPlugin(options?: Options): Plugin;
+/**
+* Walks Nitro's resolved routeRules and stamps `x-analog-no-ssr: true` onto
+* any rule with `ssr: false`, and `x-analog-no-streaming: true` onto any rule
+* with `streaming: false`. Kept as response-header hints for downstream
+* consumers (CDN, edge logic); the actual SSR short-circuit happens inside
+* the SSR renderer virtual above, and the router falls back to a buffered
+* render when it sees the streaming hint.
+*/
+export declare function injectAnalogRouteRuleHeaders(nitro: Nitro): void;