@aigne/aos 0.2.0-beta

package/dist/projectors/aup-projector.d.mts

@@ -0,0 +1,59 @@
+import { ResourceProjector } from "../mount/types.mjs";
+import { AFS, AFSModule } from "@aigne/afs";
+
+//#region src/projectors/aup-projector.d.ts
+/**
+ * @internal
+ * AUP projector singleton — the first-class abstraction.
+ */
+declare const aupResourceProjector: ResourceProjector;
+/**
+ * @internal
+ * Thin wrapper exposing the same behaviour as
+ * {@link aupResourceProjector}.project — kept as a stable function reference
+ * for the chain-as-device-placement plan, which imports this name directly.
+ */
+declare function projectAupResources(opts: {
+  afs: AFS;
+  mountPath: string;
+  resources: AFSModule;
+  scope?: "host" | "blocklet" | "instance";
+}): Promise<void>;
+/**
+ * @internal
+ * Scan an existing AFS path for `*.json` recipe files and mount each one as
+ * a hidden `AupRecipeProvider` supplement under `{mountTarget}`.
+ *
+ * Used both by `projectAupResources` (after temp-mounting an opaque
+ * resources module) and by Node's `autoSupplementAup` virtual-path flow
+ * (which already has a live AFS path to scan).
+ *
+ * Missing `scanRoot` → silent no-op, mirroring the original loader contract.
+ */
+declare function projectAupFromAfsPath(opts: {
+  afs: AFS;
+  scanRoot: string;
+  mountTarget: string;
+}): Promise<void>;
+/**
+ * @internal
+ * Parse a relative path inside an `aup/` directory into the mount-path
+ * components the supplement will occupy. Prefix segments are translated from
+ * `_param` placeholder syntax to `:param` mount syntax (see
+ * {@link translateParamSegment}); the view name is never translated.
+ *
+ * ```
+ * /default.json                  → { prefix: "",                  viewName: "default" }
+ * /transactions/item.json        → { prefix: "/transactions",     viewName: "item" }
+ * /a/b/c/view.json               → { prefix: "/a/b/c",            viewName: "view" }
+ * /bridges/_addr/blocks/item.json→ { prefix: "/bridges/:addr/blocks", viewName: "item" }
+ * /traces/_date/_runId/item.json → { prefix: "/traces/:date/:runId",  viewName: "item" }
+ * ```
+ */
+declare function parseAupFilePath(relPath: string): {
+  prefix: string;
+  viewName: string;
+};
+//#endregion
+export { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources };
+//# sourceMappingURL=aup-projector.d.mts.map

package/dist/projectors/aup-projector.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aup-projector.d.mts","names":[],"sources":["../../src/projectors/aup-projector.ts"],"mappings":";;;;;;;;cAqEa,oBAAA,EAAsB,iBAAA;;;;;AA4DnC;;iBA/CsB,mBAAA,CAAoB,IAAA;EACxC,GAAA,EAAK,GAAA;EACL,SAAA;EACA,SAAA,EAAW,SAAA;EACX,KAAA;AAAA,IACE,OAAA;;;;;AA0IJ;;;;;;;iBAhGsB,qBAAA,CAAsB,IAAA;EAC1C,GAAA,EAAK,GAAA;EACL,QAAA;EACA,WAAA;AAAA,IACE,OAAA;;;;;;;;;;;;;;;;iBA4FY,gBAAA,CAAiB,OAAA;EAAoB,MAAA;EAAgB,QAAA;AAAA"}

package/dist/projectors/aup-projector.mjs

@@ -0,0 +1,188 @@
+import { joinURL } from "ufo";
+import { AFSNotFoundError, AFSValidationError, AupRecipeProvider } from "@aigne/afs";
+
+//#region src/projectors/aup-projector.ts
+/**
+* @internal
+*
+* AUP `ResourceProjector` — projects an opaque `AFSModule` of `aup/**.json`
+* recipes onto a target mount as hidden `AupRecipeProvider` supplements.
+*
+* Runtime-neutral: the projector only uses AFS APIs and knows nothing about
+* Node fs, Cloudflare bindings, or any other runtime-specific surface. The
+* `resources` module is opaque — Node's adapter wraps a packageDir via
+* `AFSFS`, Cloudflare's adapter wraps a build-time bundled asset map, and
+* tests can wrap any in-memory `AFSModule`.
+*
+* Subpath-only export: `@aigne/aos/projectors`. Not part of the @aigne/aos
+* root contract. Cross-plan contract: chain-as-device-placement Phase 4
+* imports `projectAupResources` directly.
+*/
+const randomUUID = () => globalThis.crypto.randomUUID();
+/**
+* 1 MiB safety cap for a single recipe file. Anything larger almost
+* certainly represents a misconfiguration (e.g. a bundled asset landed in
+* `aup/`) and would balloon every mount's memory footprint.
+*
+* **Failure semantics:** oversized files and malformed JSON are surfaced as
+* `AFSValidationError` (not silent skip). This matches the legacy
+* `autoSupplementAup` contract — fail-fast over partial recipes is the
+* right default because supplements that are missing in production are
+* confusing for users and noisy in logs. The planning doc tasks.md table
+* mentions "skip + log"; the legacy implementation has always thrown, all
+* pre-existing integration tests assert throwing, and this projector
+* preserves that behaviour. If a future phase wants per-file isolation
+* the policy can be lifted to a projector option.
+*/
+const MAX_RECIPE_BYTES = 1024 * 1024;
+/** Bounded recursion depth for listing aup/ — enough for any realistic layout. */
+const MAX_LIST_DEPTH = 100;
+/** Hidden temp mount root for opaque resources modules. Dot-less to remain
+*  compatible with any future blocklet rules that reject dot-prefixed segments. */
+const TMP_MOUNT_ROOT = "/materialize-tmp";
+/** Supplement sub-path under each target (e.g. `/fix` → `/fix/.aup/default`). */
+const AUP_SUBPATH = ".aup";
+/** Top-level directory inside the resources module that holds recipe JSON. */
+const AUP_RESOURCE_ROOT = "/aup";
+/**
+* @internal
+* AUP projector singleton — the first-class abstraction.
+*/
+const aupResourceProjector = {
+	kind: "aup",
+	async project({ afs, mountPath, resources, scope }) {
+		await projectAupResources({
+			afs,
+			mountPath,
+			resources,
+			scope
+		});
+	}
+};
+/**
+* @internal
+* Thin wrapper exposing the same behaviour as
+* {@link aupResourceProjector}.project — kept as a stable function reference
+* for the chain-as-device-placement plan, which imports this name directly.
+*/
+async function projectAupResources(opts) {
+	opts.scope;
+	const tempMountPath = joinURL(TMP_MOUNT_ROOT, randomUUID());
+	try {
+		await opts.afs.mount(opts.resources, tempMountPath, { hidden: true });
+	} catch (err) {
+		if (isNotFoundError(err)) return;
+		throw err;
+	}
+	try {
+		await projectAupFromAfsPath({
+			afs: opts.afs,
+			scanRoot: joinURL(tempMountPath, AUP_RESOURCE_ROOT),
+			mountTarget: opts.mountPath
+		});
+	} finally {
+		opts.afs.unmount(tempMountPath);
+	}
+}
+/**
+* @internal
+* Scan an existing AFS path for `*.json` recipe files and mount each one as
+* a hidden `AupRecipeProvider` supplement under `{mountTarget}`.
+*
+* Used both by `projectAupResources` (after temp-mounting an opaque
+* resources module) and by Node's `autoSupplementAup` virtual-path flow
+* (which already has a live AFS path to scan).
+*
+* Missing `scanRoot` → silent no-op, mirroring the original loader contract.
+*/
+async function projectAupFromAfsPath(opts) {
+	let listResult;
+	try {
+		listResult = await opts.afs.list(opts.scanRoot, { maxDepth: MAX_LIST_DEPTH });
+	} catch (err) {
+		if (isNotFoundError(err)) return;
+		throw err;
+	}
+	const jsonFiles = (listResult.data ?? []).filter(isJsonFileEntry).sort((a, b) => (a.path ?? "").localeCompare(b.path ?? ""));
+	for (const file of jsonFiles) {
+		const relPath = file.path.slice(opts.scanRoot.length);
+		const { prefix, viewName } = parseAupFilePath(relPath);
+		const declaredSize = file.meta?.size;
+		if (typeof declaredSize === "number" && declaredSize > MAX_RECIPE_BYTES) throw new AFSValidationError(`AUP recipe file too large (> ${MAX_RECIPE_BYTES} bytes): ${relPath}`);
+		const raw = (await opts.afs.read(file.path)).data?.content;
+		const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+		if (text.length > MAX_RECIPE_BYTES) throw new AFSValidationError(`AUP recipe file too large (> ${MAX_RECIPE_BYTES} bytes): ${relPath}`);
+		let recipe;
+		try {
+			recipe = JSON.parse(text);
+		} catch (err) {
+			throw new AFSValidationError(`Failed to parse AUP recipe ${relPath}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		const supplementPath = joinURL(opts.mountTarget, prefix, AUP_SUBPATH, viewName);
+		await opts.afs.mount(new AupRecipeProvider(recipe), supplementPath, { hidden: true });
+	}
+}
+/**
+* @internal
+* Translate `aup/` placeholder syntax to AFS mount `:param` syntax within a
+* single path segment. An `_<name>` token becomes `:<name>` ONLY when the `_`
+* sits at the start of the segment or directly after a non-alphanumeric
+* separator (e.g. `-`). An underscore surrounded by alphanumerics (`my_dir`)
+* is left literal, so ordinary directory names with underscores are safe.
+*
+* ```
+* _date     → :date       (segment-leading)
+* round-_n  → round-:n     (after a `-` separator — mixed segment)
+* my_dir    → my_dir       (alphanumeric-bounded `_` — unchanged)
+* ```
+*
+* Disambiguation convention (design.md §3.2): inside `aup/`, an `_<name>`
+* token in this position is a parameter segment.
+*/
+function translateParamSegment(segment) {
+	return segment.replace(/(^|[^a-zA-Z0-9])_([a-zA-Z][a-zA-Z0-9]*)/g, "$1:$2");
+}
+/**
+* @internal
+* Parse a relative path inside an `aup/` directory into the mount-path
+* components the supplement will occupy. Prefix segments are translated from
+* `_param` placeholder syntax to `:param` mount syntax (see
+* {@link translateParamSegment}); the view name is never translated.
+*
+* ```
+* /default.json                  → { prefix: "",                  viewName: "default" }
+* /transactions/item.json        → { prefix: "/transactions",     viewName: "item" }
+* /a/b/c/view.json               → { prefix: "/a/b/c",            viewName: "view" }
+* /bridges/_addr/blocks/item.json→ { prefix: "/bridges/:addr/blocks", viewName: "item" }
+* /traces/_date/_runId/item.json → { prefix: "/traces/:date/:runId",  viewName: "item" }
+* ```
+*/
+function parseAupFilePath(relPath) {
+	if (!relPath || relPath.trim() === "") throw new Error("parseAupFilePath: path is empty");
+	const normalized = (relPath.startsWith("/") ? relPath : `/${relPath}`).replace(/\/+/g, "/").replace(/\/+$/, "");
+	if (!normalized.endsWith(".json")) throw new Error(`parseAupFilePath: file must end with .json, got "${relPath}"`);
+	const segments = normalized.split("/").filter(Boolean);
+	if (segments.some((s) => s === "..")) throw new Error(`parseAupFilePath: path traversal not allowed: "${relPath}"`);
+	const viewName = segments.pop().slice(0, -5);
+	if (!viewName) throw new Error(`parseAupFilePath: view name is empty for "${relPath}"`);
+	return {
+		prefix: segments.length === 0 ? "" : `/${segments.map(translateParamSegment).join("/")}`,
+		viewName
+	};
+}
+function isJsonFileEntry(entry) {
+	if (!entry.path?.endsWith(".json")) return false;
+	return entry.meta?.kind !== "fs:directory";
+}
+function isNotFoundError(err) {
+	if (err instanceof AFSNotFoundError) return true;
+	if (err instanceof Error) {
+		if (err.code === "ENOENT") return true;
+		if (/ENOENT|no such file or directory|not found/i.test(err.message)) return true;
+	}
+	return false;
+}
+
+//#endregion
+export { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources };
+//# sourceMappingURL=aup-projector.mjs.map

package/dist/projectors/aup-projector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aup-projector.mjs","names":[],"sources":["../../src/projectors/aup-projector.ts"],"sourcesContent":["/**\n * @internal\n *\n * AUP `ResourceProjector` — projects an opaque `AFSModule` of `aup/**.json`\n * recipes onto a target mount as hidden `AupRecipeProvider` supplements.\n *\n * Runtime-neutral: the projector only uses AFS APIs and knows nothing about\n * Node fs, Cloudflare bindings, or any other runtime-specific surface. The\n * `resources` module is opaque — Node's adapter wraps a packageDir via\n * `AFSFS`, Cloudflare's adapter wraps a build-time bundled asset map, and\n * tests can wrap any in-memory `AFSModule`.\n *\n * Subpath-only export: `@aigne/aos/projectors`. Not part of the @aigne/aos\n * root contract. Cross-plan contract: chain-as-device-placement Phase 4\n * imports `projectAupResources` directly.\n */\n\nimport {\n  type AFS,\n  type AFSEntry,\n  type AFSListResult,\n  type AFSModule,\n  AFSNotFoundError,\n  AFSValidationError,\n  AupRecipeProvider,\n} from \"@aigne/afs\";\nimport { joinURL } from \"ufo\";\n\n// Web Crypto API — available in Node 19+ and Cloudflare Workers, so the\n// projector remains runtime-neutral and importable from CF without\n// pulling in `node:crypto`.\nconst randomUUID = (): string => globalThis.crypto.randomUUID();\n\nimport type { ResourceProjector } from \"../mount/types.js\";\n\n/**\n * 1 MiB safety cap for a single recipe file. Anything larger almost\n * certainly represents a misconfiguration (e.g. a bundled asset landed in\n * `aup/`) and would balloon every mount's memory footprint.\n *\n * **Failure semantics:** oversized files and malformed JSON are surfaced as\n * `AFSValidationError` (not silent skip). This matches the legacy\n * `autoSupplementAup` contract — fail-fast over partial recipes is the\n * right default because supplements that are missing in production are\n * confusing for users and noisy in logs. The planning doc tasks.md table\n * mentions \"skip + log\"; the legacy implementation has always thrown, all\n * pre-existing integration tests assert throwing, and this projector\n * preserves that behaviour. If a future phase wants per-file isolation\n * the policy can be lifted to a projector option.\n */\nconst MAX_RECIPE_BYTES = 1024 * 1024;\n\n/** Bounded recursion depth for listing aup/ — enough for any realistic layout. */\nconst MAX_LIST_DEPTH = 100;\n\n/** Hidden temp mount root for opaque resources modules. Dot-less to remain\n *  compatible with any future blocklet rules that reject dot-prefixed segments. */\nconst TMP_MOUNT_ROOT = \"/materialize-tmp\";\n\n/** Supplement sub-path under each target (e.g. `/fix` → `/fix/.aup/default`). */\nconst AUP_SUBPATH = \".aup\";\n\n/** Top-level directory inside the resources module that holds recipe JSON. */\nconst AUP_RESOURCE_ROOT = \"/aup\";\n\n/**\n * @internal\n * AUP projector singleton — the first-class abstraction.\n */\nexport const aupResourceProjector: ResourceProjector = {\n  kind: \"aup\",\n  async project({ afs, mountPath, resources, scope }) {\n    await projectAupResources({ afs, mountPath, resources, scope });\n  },\n};\n\n/**\n * @internal\n * Thin wrapper exposing the same behaviour as\n * {@link aupResourceProjector}.project — kept as a stable function reference\n * for the chain-as-device-placement plan, which imports this name directly.\n */\nexport async function projectAupResources(opts: {\n  afs: AFS;\n  mountPath: string;\n  resources: AFSModule;\n  scope?: \"host\" | \"blocklet\" | \"instance\";\n}): Promise<void> {\n  // scope is accepted for cross-plan symmetry (chain-as-device-placement\n  // Phase 4 forwards it) but the projector is currently scope-agnostic;\n  // future policies (per-scope size limits, namespacing) will read it.\n  const _scope = opts.scope ?? \"host\";\n  void _scope;\n\n  const tempMountPath = joinURL(TMP_MOUNT_ROOT, randomUUID());\n\n  try {\n    await opts.afs.mount(opts.resources, tempMountPath, { hidden: true });\n  } catch (err) {\n    // A resources module that can't be mounted is treated as \"no recipes\" —\n    // matches the original Node-only loader where a missing `aup/` directory\n    // is a silent no-op.\n    if (isNotFoundError(err)) return;\n    throw err;\n  }\n\n  try {\n    await projectAupFromAfsPath({\n      afs: opts.afs,\n      scanRoot: joinURL(tempMountPath, AUP_RESOURCE_ROOT),\n      mountTarget: opts.mountPath,\n    });\n  } finally {\n    // Sync API — do NOT await.\n    opts.afs.unmount(tempMountPath);\n  }\n}\n\n/**\n * @internal\n * Scan an existing AFS path for `*.json` recipe files and mount each one as\n * a hidden `AupRecipeProvider` supplement under `{mountTarget}`.\n *\n * Used both by `projectAupResources` (after temp-mounting an opaque\n * resources module) and by Node's `autoSupplementAup` virtual-path flow\n * (which already has a live AFS path to scan).\n *\n * Missing `scanRoot` → silent no-op, mirroring the original loader contract.\n */\nexport async function projectAupFromAfsPath(opts: {\n  afs: AFS;\n  scanRoot: string;\n  mountTarget: string;\n}): Promise<void> {\n  let listResult: AFSListResult;\n  try {\n    listResult = await opts.afs.list(opts.scanRoot, { maxDepth: MAX_LIST_DEPTH });\n  } catch (err) {\n    if (isNotFoundError(err)) return;\n    throw err;\n  }\n\n  const jsonFiles = (listResult.data ?? [])\n    .filter(isJsonFileEntry)\n    // Deterministic order makes test assertions and log output reproducible.\n    .sort((a, b) => (a.path ?? \"\").localeCompare(b.path ?? \"\"));\n\n  for (const file of jsonFiles) {\n    const relPath = file.path!.slice(opts.scanRoot.length);\n    const { prefix, viewName } = parseAupFilePath(relPath);\n\n    const declaredSize = file.meta?.size;\n    if (typeof declaredSize === \"number\" && declaredSize > MAX_RECIPE_BYTES) {\n      throw new AFSValidationError(\n        `AUP recipe file too large (> ${MAX_RECIPE_BYTES} bytes): ${relPath}`,\n      );\n    }\n\n    const readResult = await opts.afs.read(file.path!);\n    const raw = readResult.data?.content;\n    const text = typeof raw === \"string\" ? raw : new TextDecoder().decode(raw as Uint8Array);\n\n    if (text.length > MAX_RECIPE_BYTES) {\n      throw new AFSValidationError(\n        `AUP recipe file too large (> ${MAX_RECIPE_BYTES} bytes): ${relPath}`,\n      );\n    }\n\n    let recipe: unknown;\n    try {\n      recipe = JSON.parse(text);\n    } catch (err) {\n      const detail = err instanceof Error ? err.message : String(err);\n      throw new AFSValidationError(`Failed to parse AUP recipe ${relPath}: ${detail}`);\n    }\n\n    const supplementPath = joinURL(opts.mountTarget, prefix, AUP_SUBPATH, viewName);\n    // hidden: true → routable for read but invisible in parent list() so the\n    // user-browsable tree is not polluted with .aup/ entries.\n    //\n    // When `prefix` carries a `:param` segment (translated from an `_param`\n    // directory by parseAupFilePath, e.g. `aup/traces/_date/...`), `supplementPath`\n    // is a pattern path like `/{mount}/traces/:date/.aup/default`. AFS.mount\n    // auto-detects the `:param` segment and registers a hidden PATTERN mount —\n    // no branch needed here; literal and pattern recipes share this one call.\n    await opts.afs.mount(new AupRecipeProvider(recipe), supplementPath, { hidden: true });\n  }\n}\n\n/**\n * @internal\n * Translate `aup/` placeholder syntax to AFS mount `:param` syntax within a\n * single path segment. An `_<name>` token becomes `:<name>` ONLY when the `_`\n * sits at the start of the segment or directly after a non-alphanumeric\n * separator (e.g. `-`). An underscore surrounded by alphanumerics (`my_dir`)\n * is left literal, so ordinary directory names with underscores are safe.\n *\n * ```\n * _date     → :date       (segment-leading)\n * round-_n  → round-:n     (after a `-` separator — mixed segment)\n * my_dir    → my_dir       (alphanumeric-bounded `_` — unchanged)\n * ```\n *\n * Disambiguation convention (design.md §3.2): inside `aup/`, an `_<name>`\n * token in this position is a parameter segment.\n */\nfunction translateParamSegment(segment: string): string {\n  return segment.replace(/(^|[^a-zA-Z0-9])_([a-zA-Z][a-zA-Z0-9]*)/g, \"$1:$2\");\n}\n\n/**\n * @internal\n * Parse a relative path inside an `aup/` directory into the mount-path\n * components the supplement will occupy. Prefix segments are translated from\n * `_param` placeholder syntax to `:param` mount syntax (see\n * {@link translateParamSegment}); the view name is never translated.\n *\n * ```\n * /default.json                  → { prefix: \"\",                  viewName: \"default\" }\n * /transactions/item.json        → { prefix: \"/transactions\",     viewName: \"item\" }\n * /a/b/c/view.json               → { prefix: \"/a/b/c\",            viewName: \"view\" }\n * /bridges/_addr/blocks/item.json→ { prefix: \"/bridges/:addr/blocks\", viewName: \"item\" }\n * /traces/_date/_runId/item.json → { prefix: \"/traces/:date/:runId\",  viewName: \"item\" }\n * ```\n */\nexport function parseAupFilePath(relPath: string): { prefix: string; viewName: string } {\n  if (!relPath || relPath.trim() === \"\") {\n    throw new Error(\"parseAupFilePath: path is empty\");\n  }\n\n  const withLeading = relPath.startsWith(\"/\") ? relPath : `/${relPath}`;\n  const normalized = withLeading.replace(/\\/+/g, \"/\").replace(/\\/+$/, \"\");\n\n  if (!normalized.endsWith(\".json\")) {\n    throw new Error(`parseAupFilePath: file must end with .json, got \"${relPath}\"`);\n  }\n\n  const segments = normalized.split(\"/\").filter(Boolean);\n\n  if (segments.some((s) => s === \"..\")) {\n    throw new Error(`parseAupFilePath: path traversal not allowed: \"${relPath}\"`);\n  }\n\n  const last = segments.pop()!;\n  const viewName = last.slice(0, -\".json\".length);\n  if (!viewName) {\n    throw new Error(`parseAupFilePath: view name is empty for \"${relPath}\"`);\n  }\n\n  // Translate placeholder dirs (`_date` → `:date`) so the supplement mounts on\n  // a pattern path. View name stays literal — views are never parameters.\n  const prefix = segments.length === 0 ? \"\" : `/${segments.map(translateParamSegment).join(\"/\")}`;\n  return { prefix, viewName };\n}\n\nfunction isJsonFileEntry(entry: AFSEntry): boolean {\n  if (!entry.path?.endsWith(\".json\")) return false;\n  // AFSFS tags directory entries with `meta.kind: \"fs:directory\"`. Any other\n  // kind (or a missing kind) is treated as a file candidate so the same logic\n  // works for AFSFS, AFSMemory, and bundled-asset-style modules alike.\n  const kind = entry.meta?.kind;\n  return kind !== \"fs:directory\";\n}\n\nfunction isNotFoundError(err: unknown): boolean {\n  if (err instanceof AFSNotFoundError) return true;\n  if (err instanceof Error) {\n    const code = (err as { code?: string }).code;\n    if (code === \"ENOENT\") return true;\n    if (/ENOENT|no such file or directory|not found/i.test(err.message)) return true;\n  }\n  return false;\n}\n"],"mappings":"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"}

package/dist/projectors/index.cjs

@@ -0,0 +1,6 @@
+const require_aup_projector = require('./aup-projector.cjs');
+
+exports.aupResourceProjector = require_aup_projector.aupResourceProjector;
+exports.parseAupFilePath = require_aup_projector.parseAupFilePath;
+exports.projectAupFromAfsPath = require_aup_projector.projectAupFromAfsPath;
+exports.projectAupResources = require_aup_projector.projectAupResources;

package/dist/projectors/index.d.cts

@@ -0,0 +1,2 @@
+import { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources } from "./aup-projector.cjs";
+export { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources };

package/dist/projectors/index.d.mts

@@ -0,0 +1,2 @@
+import { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources } from "./aup-projector.mjs";
+export { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources };

package/dist/projectors/index.mjs

@@ -0,0 +1,3 @@
+import { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources } from "./aup-projector.mjs";
+
+export { aupResourceProjector, parseAupFilePath, projectAupFromAfsPath, projectAupResources };

package/dist/scaffold/afs.cjs

@@ -0,0 +1,195 @@
+const require_manifest_dsl = require('./manifest-dsl.cjs');
+const require_module_dsl = require('./module-dsl.cjs');
+const require_shell_dsl = require('./shell-dsl.cjs');
+const require_surface_dsl = require('./surface-dsl.cjs');
+const require_workspace_dsl = require('./workspace-dsl.cjs');
+let ufo = require("ufo");
+
+//#region src/scaffold/afs.ts
+const DEFAULT_SCAFFOLD_ROOT = "/.scaffold";
+async function loadScaffoldDefinition(reader, options = {}) {
+	const root = options.root ?? DEFAULT_SCAFFOLD_ROOT;
+	const manifest = await loadManifestDslDefinition(reader, root) ?? await readOptionalJSON(reader, (0, ufo.joinURL)(root, "manifest.json")) ?? { title: "App" };
+	const shellDsl = await loadShellDslDefinition(reader, root);
+	const shell = {
+		menu: shellDsl?.menu ?? normalizeMenu(await readOptionalJSON(reader, (0, ufo.joinURL)(root, "shell/menu.json"))),
+		header: shellDsl?.header ?? await readOptionalJSON(reader, (0, ufo.joinURL)(root, "shell/header.json")),
+		footer: shellDsl?.footer ?? await readOptionalJSON(reader, (0, ufo.joinURL)(root, "shell/footer.json")),
+		workspace: await loadWorkspaceDefinition(reader, root)
+	};
+	const modules = await loadModuleRecords(reader, (0, ufo.joinURL)(root, "modules"));
+	const surfaces = await loadSurfaceRecords(reader, (0, ufo.joinURL)(root, "surfaces"));
+	return {
+		manifest,
+		shell: normalizeShell(shell),
+		modules: sortByOrderThenTitle(modules),
+		surfaces: sortByOrderThenTitle(surfaces)
+	};
+}
+async function loadManifestDslDefinition(reader, root) {
+	const dsl = await readOptionalText(reader, (0, ufo.joinURL)(root, "manifest.dsl"));
+	if (dsl !== void 0) return require_manifest_dsl.compileManifestDsl(dsl);
+}
+async function loadShellDslDefinition(reader, root) {
+	const dsl = await readOptionalText(reader, (0, ufo.joinURL)(root, "shell/shell.dsl"));
+	if (dsl !== void 0) return require_shell_dsl.compileShellDsl(dsl);
+}
+async function loadWorkspaceDefinition(reader, root) {
+	const dsl = await readOptionalText(reader, (0, ufo.joinURL)(root, "shell/workspace.dsl"));
+	if (dsl !== void 0) return require_workspace_dsl.compileWorkspaceDsl(dsl);
+	return await readOptionalJSON(reader, (0, ufo.joinURL)(root, "shell/workspace.json"));
+}
+async function loadModuleRecords(reader, root) {
+	if (!await hasDirectory(reader, root)) return [];
+	const entries = await listVisible(reader, root);
+	const records = [];
+	const dslIds = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		const path = entryPath(root, entry);
+		if (isDirectoryEntry(entry)) {
+			const dsl = await readOptionalText(reader, (0, ufo.joinURL)(path, "module.dsl"));
+			if (dsl !== void 0) {
+				const record = require_module_dsl.compileModuleDsl(dsl);
+				records.push(record);
+				dslIds.add(record.id);
+				continue;
+			}
+			const nested = await readOptionalJSON(reader, (0, ufo.joinURL)(path, "module.json"));
+			if (nested) records.push(nested);
+			continue;
+		}
+		if (entry.id.endsWith(".module.dsl")) {
+			const record = require_module_dsl.compileModuleDsl(await readOptionalText(reader, path) ?? "");
+			records.push(record);
+			dslIds.add(record.id);
+		}
+	}
+	for (const entry of entries) {
+		if (isDirectoryEntry(entry) || !entry.id.endsWith(".module.json")) continue;
+		const parsed = await readJSON(reader, entryPath(root, entry));
+		if (dslIds.has(parsed.id)) continue;
+		records.push(parsed);
+	}
+	return records;
+}
+async function loadSurfaceRecords(reader, root) {
+	if (!await hasDirectory(reader, root)) return [];
+	const entries = await listVisible(reader, root);
+	const records = [];
+	const dslIds = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		const path = entryPath(root, entry);
+		if (isDirectoryEntry(entry)) {
+			const dsl = await readOptionalText(reader, (0, ufo.joinURL)(path, "surface.dsl"));
+			if (dsl !== void 0) {
+				const record = require_surface_dsl.compileSurfaceDsl(dsl);
+				records.push(record);
+				dslIds.add(record.id);
+				continue;
+			}
+			const nested = await readOptionalJSON(reader, (0, ufo.joinURL)(path, "surface.json"));
+			if (nested) records.push(nested);
+			continue;
+		}
+		if (entry.id.endsWith(".surface.dsl")) {
+			const record = require_surface_dsl.compileSurfaceDsl(await readOptionalText(reader, path) ?? "");
+			records.push(record);
+			dslIds.add(record.id);
+		}
+	}
+	for (const entry of entries) {
+		if (isDirectoryEntry(entry) || !entry.id.endsWith(".surface.json")) continue;
+		const parsed = await readJSON(reader, entryPath(root, entry));
+		if (dslIds.has(parsed.id)) continue;
+		records.push(parsed);
+	}
+	return records;
+}
+function normalizeShell(shell) {
+	return {
+		...shell,
+		menu: normalizeMenu(shell.menu),
+		header: shell.header ? {
+			...shell.header,
+			actions: sortByOrderThenTitle(shell.header.actions ?? [])
+		} : void 0,
+		footer: shell.footer ? {
+			...shell.footer,
+			links: sortByOrderThenTitle(shell.footer.links ?? [])
+		} : void 0,
+		workspace: shell.workspace ? normalizeWorkspace(shell.workspace) : void 0
+	};
+}
+function normalizeWorkspace(workspace) {
+	return {
+		...workspace,
+		sections: sortByOrderThenTitle(workspace.sections ?? []).map((section) => ({
+			...section,
+			roots: sortByOrderThenTitle(section.roots ?? [])
+		}))
+	};
+}
+function normalizeMenu(menu) {
+	if (!menu) return void 0;
+	return { groups: sortByOrderThenTitle(Array.isArray(menu) ? menu : menu.groups).map((group) => ({
+		...group,
+		items: normalizeMenuItems(group.items ?? [])
+	})) };
+}
+function normalizeMenuItems(items) {
+	return sortByOrderThenTitle(items).map((item) => ({
+		...item,
+		children: item.children ? normalizeMenuItems(item.children) : void 0
+	}));
+}
+function sortByOrderThenTitle(items) {
+	return [...items].sort((left, right) => normalizeOrder(left.order) - normalizeOrder(right.order) || (left.title ?? left.id ?? "").localeCompare(right.title ?? right.id ?? ""));
+}
+function normalizeOrder(order) {
+	return order ?? Number.MAX_SAFE_INTEGER;
+}
+async function hasDirectory(reader, path) {
+	try {
+		const result = await reader.list(path);
+		return Array.isArray(result.data);
+	} catch {
+		return false;
+	}
+}
+async function listVisible(reader, path) {
+	return ((await reader.list(path)).data ?? []).filter((entry) => entry?.id && !entry.id.startsWith("."));
+}
+async function readOptionalJSON(reader, path) {
+	try {
+		return await readJSON(reader, path);
+	} catch {
+		return;
+	}
+}
+async function readOptionalText(reader, path) {
+	try {
+		const data = (await reader.read(path)).data;
+		const content = data && typeof data === "object" && "content" in data ? data.content : data;
+		return typeof content === "string" ? content : void 0;
+	} catch {
+		return;
+	}
+}
+async function readJSON(reader, path) {
+	const data = (await reader.read(path)).data;
+	const content = data && typeof data === "object" && "content" in data ? data.content : data;
+	if (typeof content === "string") return JSON.parse(content);
+	if (content && typeof content === "object") return content;
+	throw new Error(`Expected JSON object in "${path}"`);
+}
+function isDirectoryEntry(entry) {
+	const meta = entry.meta ?? {};
+	return meta.kind === "fs:directory" || meta.kind === "directory" || Array.isArray(meta.kinds) && meta.kinds.includes("fs:directory") || typeof meta.childrenCount === "number";
+}
+function entryPath(parentPath, entry) {
+	return entry.path || (0, ufo.joinURL)(parentPath, entry.id);
+}
+
+//#endregion
+exports.DEFAULT_SCAFFOLD_ROOT = DEFAULT_SCAFFOLD_ROOT;
+exports.loadScaffoldDefinition = loadScaffoldDefinition;

package/dist/scaffold/afs.d.cts

@@ -0,0 +1,16 @@
+import { ScaffoldDefinition } from "./types.cjs";
+import { AFSListResult, AFSReadResult } from "@aigne/afs";
+
+//#region src/scaffold/afs.d.ts
+declare const DEFAULT_SCAFFOLD_ROOT = "/.scaffold";
+interface ScaffoldAfsReader {
+  list(path: string): Promise<AFSListResult>;
+  read(path: string): Promise<AFSReadResult>;
+}
+interface LoadScaffoldDefinitionOptions {
+  root?: string;
+}
+declare function loadScaffoldDefinition(reader: ScaffoldAfsReader, options?: LoadScaffoldDefinitionOptions): Promise<ScaffoldDefinition>;
+//#endregion
+export { DEFAULT_SCAFFOLD_ROOT, LoadScaffoldDefinitionOptions, ScaffoldAfsReader, loadScaffoldDefinition };
+//# sourceMappingURL=afs.d.cts.map

package/dist/scaffold/afs.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afs.d.cts","names":[],"sources":["../../src/scaffold/afs.ts"],"mappings":";;;;cAoBa,qBAAA;AAAA,UAEI,iBAAA;EACf,IAAA,CAAK,IAAA,WAAe,OAAA,CAAQ,aAAA;EAC5B,IAAA,CAAK,IAAA,WAAe,OAAA,CAAQ,aAAA;AAAA;AAAA,UAGb,6BAAA;EACf,IAAA;AAAA;AAAA,iBAGoB,sBAAA,CACpB,MAAA,EAAQ,iBAAA,EACR,OAAA,GAAS,6BAAA,GACR,OAAA,CAAQ,kBAAA"}

package/dist/scaffold/afs.d.mts

@@ -0,0 +1,16 @@
+import { ScaffoldDefinition } from "./types.mjs";
+import { AFSListResult, AFSReadResult } from "@aigne/afs";
+
+//#region src/scaffold/afs.d.ts
+declare const DEFAULT_SCAFFOLD_ROOT = "/.scaffold";
+interface ScaffoldAfsReader {
+  list(path: string): Promise<AFSListResult>;
+  read(path: string): Promise<AFSReadResult>;
+}
+interface LoadScaffoldDefinitionOptions {
+  root?: string;
+}
+declare function loadScaffoldDefinition(reader: ScaffoldAfsReader, options?: LoadScaffoldDefinitionOptions): Promise<ScaffoldDefinition>;
+//#endregion
+export { DEFAULT_SCAFFOLD_ROOT, LoadScaffoldDefinitionOptions, ScaffoldAfsReader, loadScaffoldDefinition };
+//# sourceMappingURL=afs.d.mts.map

package/dist/scaffold/afs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afs.d.mts","names":[],"sources":["../../src/scaffold/afs.ts"],"mappings":";;;;cAoBa,qBAAA;AAAA,UAEI,iBAAA;EACf,IAAA,CAAK,IAAA,WAAe,OAAA,CAAQ,aAAA;EAC5B,IAAA,CAAK,IAAA,WAAe,OAAA,CAAQ,aAAA;AAAA;AAAA,UAGb,6BAAA;EACf,IAAA;AAAA;AAAA,iBAGoB,sBAAA,CACpB,MAAA,EAAQ,iBAAA,EACR,OAAA,GAAS,6BAAA,GACR,OAAA,CAAQ,kBAAA"}