@skmtc/core 0.28.4 → 0.28.6

package/esm/types/InsertOptions.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview The trailing argument of an insert call: placement and
+ * export settings plus the peer's caller options.
+ *
+ * @module InsertOptions
+ */
+import type { ProjectionOptionsArg, ProjectionOptionsRest } from './ProjectionOptions.js';
+/** Settings a caller may set when inserting a peer into the caller's own file. */
+export type PeerInsertSettings = {
+    /** Whether to exclude the peer's definition from exports */
+    noExport?: boolean;
+    /**
+     * Target variant of the peer projection. Omit for `'main'`; pass only
+     * when the peer declares this variant — the Driver throws on mismatch.
+     */
+    variant?: string;
+};
+/** {@link PeerInsertSettings} plus the file to import the peer into. */
+export type InsertSettings = PeerInsertSettings & {
+    /** Custom destination path for the peer's definition */
+    destinationPath?: string;
+};
+/**
+ * {@link PeerInsertSettings} plus the peer's caller options. `NoInfer`
+ * keeps `ProjectionOptions` inferred from the projection alone.
+ */
+export type PeerInsertOptions<ProjectionOptions = undefined> = PeerInsertSettings & ProjectionOptionsArg<NoInfer<ProjectionOptions>>;
+/** {@link InsertSettings} plus the peer's caller options. */
+export type InsertOptions<ProjectionOptions = undefined> = InsertSettings & ProjectionOptionsArg<NoInfer<ProjectionOptions>>;
+/**
+ * The keys a caller may set on a peer insertion, picked off the trailing
+ * argument so nothing else on it reaches the engine.
+ */
+export declare const toPeerInsertOptions: <ProjectionOptions>(rest: ProjectionOptionsRest<PeerInsertOptions<ProjectionOptions>, ProjectionOptions>) => PeerInsertSettings & {
+    options: ProjectionOptions;
+};
+/** {@link toPeerInsertOptions} plus the destination path, for `context.insertModel`. */
+export declare const toInsertOptions: <ProjectionOptions>(rest: ProjectionOptionsRest<InsertOptions<ProjectionOptions>, ProjectionOptions>) => InsertSettings & {
+    options: ProjectionOptions;
+};

package/esm/types/InsertOptions.js

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview The trailing argument of an insert call: placement and
+ * export settings plus the peer's caller options.
+ *
+ * @module InsertOptions
+ */
+import { readProjectionOptions } from './ProjectionOptions.js';
+/**
+ * The keys a caller may set on a peer insertion, picked off the trailing
+ * argument so nothing else on it reaches the engine.
+ */
+export const toPeerInsertOptions = (rest) => {
+    const [args] = rest;
+    return {
+        noExport: args?.noExport,
+        variant: args?.variant,
+        options: readProjectionOptions(args)
+    };
+};
+/** {@link toPeerInsertOptions} plus the destination path, for `context.insertModel`. */
+export const toInsertOptions = (rest) => {
+    const [args] = rest;
+    return {
+        noExport: args?.noExport,
+        destinationPath: args?.destinationPath,
+        variant: args?.variant,
+        options: readProjectionOptions(args)
+    };
+};

package/esm/types/JsonPointer.d.ts

@@ -89,4 +89,3 @@ export declare const append: (pointer: JsonPointer, ...segments: string[]) => Js
  * followed by `0` or `1` (a stricter validator could).
  */
 export declare const isJsonPointer: (value: unknown) => value is JsonPointer;
-//# sourceMappingURL=JsonPointer.d.ts.map

package/esm/types/Logger.d.ts

@@ -6,4 +6,3 @@ import type * as log from '../deps/jsr.io/@std/log/0.224.14/mod.js';
  * while providing type-safe logging throughout the SKMTC pipeline.
  */
 export type Logger = log.Logger;
-//# sourceMappingURL=Logger.d.ts.map

package/esm/types/Manifest.d.ts

@@ -122,4 +122,3 @@ export type ManifestContent = {
     endAt: number;
 };
 export declare const manifestContent: v.GenericSchema<ManifestContent>;
-//# sourceMappingURL=Manifest.d.ts.map

package/esm/types/Method.d.ts

@@ -28,4 +28,3 @@ export declare const method: v.UnionSchema<[
 export type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
 export declare const methods: v.ArraySchema<typeof method, undefined>;
 export declare const isMethod: (arg: unknown) => arg is Method;
-//# sourceMappingURL=Method.d.ts.map

package/esm/types/Modifiers.d.ts

@@ -71,4 +71,3 @@ export type Modifiers = {
     /** Whether the field can be null (affects null union types) */
     nullable?: boolean;
 };
-//# sourceMappingURL=Modifiers.d.ts.map

package/esm/types/ModuleExport.d.ts

@@ -135,4 +135,3 @@ export type ModuleExport = {
     /** The file path where the export can be found */
     exportPath: string;
 };
-//# sourceMappingURL=ModuleExport.d.ts.map

package/esm/types/ModuleSelect.d.ts

@@ -78,4 +78,3 @@ export declare const moduleSelect: (moduleType: string) => v.GenericSchema<Modul
  * deliberately `unknown`.
  */
 export declare const moduleTypeOf: (schema: unknown) => string | undefined;
-//# sourceMappingURL=ModuleSelect.d.ts.map

package/esm/types/OasBase.d.ts

@@ -37,4 +37,3 @@ export declare class OasBase {
     stackTrail: StackTrail;
     constructor(context?: ParseContextType);
 }
-//# sourceMappingURL=OasBase.d.ts.map

package/esm/types/Preview.d.ts

@@ -180,4 +180,3 @@ export declare const previewModule: v.GenericSchema<PreviewModule>;
  * Validates complete preview structures including module and source information.
  */
 export declare const preview: v.GenericSchema<Preview>;
-//# sourceMappingURL=Preview.d.ts.map

package/esm/types/ProjectionOptions.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Caller options for projections.
+ *
+ * Options are typed data the CALLING generator passes when it inserts a
+ * peer: `context.insertModel(Peer, refName, { options })`. Enrichments are
+ * the user's per-subject configuration and a variant selects one of them;
+ * options belong to the caller.
+ *
+ * A projection declares its options type on its base factory. The
+ * constructor and the identity statics (`toIdentifierName`,
+ * `toExportPath`) receive a plain `options` field, the base class stores
+ * it as `this.options`, and the Drivers infer the type from the projection
+ * class. Core never names a specific options type.
+ *
+ * Options take part in identity: the engine caches definitions by name and
+ * export path, so a projection whose output depends on its options must
+ * fold them into `toIdentifierName`. A cache hit whose options differ from
+ * the call's throws. Options are held by reference until render, so pass a
+ * fresh object per insertion.
+ *
+ * @module ProjectionOptions
+ */
+/**
+ * The `options` slot on an insert call. Required when the projection
+ * declares options, and `undefined`-only when it declares none, so a stray
+ * `options` on such a call is a type error. Include `undefined` in the
+ * declared type to make the slot optional.
+ */
+export type ProjectionOptionsArg<ProjectionOptions> = undefined extends ProjectionOptions ? {
+    options?: ProjectionOptions;
+} : {
+    options: ProjectionOptions;
+};
+/**
+ * The trailing parameter of an insert call, optional only when the
+ * projection's options are. Read it with `toInsertOptions` /
+ * `toPeerInsertOptions`, which pick the known keys off it.
+ */
+export type ProjectionOptionsRest<Args, ProjectionOptions> = undefined extends ProjectionOptions ? [args?: Args] : [args: Args];
+/**
+ * Read the caller's options off an insert call inside generic code.
+ *
+ * While `ProjectionOptions` is a type parameter, a direct `args.options`
+ * reads as `ProjectionOptions | undefined`: the compiler cannot see that
+ * the key is only absent when `undefined` is already a member. The
+ * overload states that once. Pass the type argument explicitly.
+ */
+export declare function readProjectionOptions<ProjectionOptions>(args: ProjectionOptionsArg<ProjectionOptions> | undefined): ProjectionOptions;
+/** The options a built value carries; `undefined` for a value that stores none. */
+export declare const toValueOptions: (value: object) => unknown;

package/esm/types/ProjectionOptions.js

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Caller options for projections.
+ *
+ * Options are typed data the CALLING generator passes when it inserts a
+ * peer: `context.insertModel(Peer, refName, { options })`. Enrichments are
+ * the user's per-subject configuration and a variant selects one of them;
+ * options belong to the caller.
+ *
+ * A projection declares its options type on its base factory. The
+ * constructor and the identity statics (`toIdentifierName`,
+ * `toExportPath`) receive a plain `options` field, the base class stores
+ * it as `this.options`, and the Drivers infer the type from the projection
+ * class. Core never names a specific options type.
+ *
+ * Options take part in identity: the engine caches definitions by name and
+ * export path, so a projection whose output depends on its options must
+ * fold them into `toIdentifierName`. A cache hit whose options differ from
+ * the call's throws. Options are held by reference until render, so pass a
+ * fresh object per insertion.
+ *
+ * @module ProjectionOptions
+ */
+export function readProjectionOptions(args) {
+    return args?.options;
+}
+/** The options a built value carries; `undefined` for a value that stores none. */
+export const toValueOptions = (value) => 'options' in value ? value.options : undefined;

package/esm/types/RefName.d.ts

@@ -132,4 +132,3 @@ import type { Brand } from './Brand.js';
  * @see {@link Brand} for the underlying branding mechanism
  */
 export type RefName = Brand<string, 'RefName'>;
-//# sourceMappingURL=RefName.d.ts.map

package/esm/types/Results.d.ts

@@ -136,4 +136,3 @@ export interface ResultsItem {
  * supporting nested hierarchical result structures.
  */
 export declare const resultsItem: v.GenericSchema<ResultsItem>;
-//# sourceMappingURL=Results.d.ts.map

package/esm/types/SchemaPath.d.ts

@@ -14,4 +14,3 @@ export type SchemaPath = string[];
  * array of strings.
  */
 export declare const schemaPath: v.GenericSchema<SchemaPath>;
-//# sourceMappingURL=SchemaPath.d.ts.map

package/esm/types/Settings.d.ts

@@ -61,6 +61,17 @@ import { type Method } from './Method.js';
  * that otherwise misplaces every artifact silently.
  */
 export declare const modulePackage: v.GenericSchema<ModulePackage>;
+/**
+ * Valibot schema for `settings.packages` as a whole.
+ *
+ * Roots are folders compared in canonical spelling ({@link toWorkspacePath}),
+ * so two entries for one folder are a mistake however they are spelled, and
+ * the workspace root itself is not a package root — with no `packages` every
+ * file already imports through the workspace alias, and a root holding every
+ * path would also hold every bare module specifier. Roots may nest: a nested
+ * root is a subpath export of the package around it.
+ */
+export declare const modulePackages: v.GenericSchema<ModulePackage[]>;
 /**
  * Configuration for a module package in the generation output.
  *
@@ -509,4 +520,3 @@ export type SkmtcClientConfig = {
  * and client settings structure.
  */
 export declare const skmtcClientConfig: v.GenericSchema<SkmtcClientConfig>;
-//# sourceMappingURL=Settings.d.ts.map

package/esm/types/Settings.js

@@ -52,6 +52,7 @@ import "../_dnt.polyfills.js";
 import { generatorEnrichments } from './Enrichments.js';
 import * as v from 'valibot';
 import { method } from './Method.js';
+import { toWorkspacePath } from '../helpers/toWorkspacePath.js';
 /**
  * Whether a relative path contains a `..` parent-reference segment.
  * `..` is a parent reference only as a whole path segment — a
@@ -72,6 +73,38 @@ export const modulePackage = v.object({
         'so each rootPath is written forward from it')),
     moduleName: v.optional(v.string())
 });
+/**
+ * Valibot schema for `settings.packages` as a whole.
+ *
+ * Roots are folders compared in canonical spelling ({@link toWorkspacePath}),
+ * so two entries for one folder are a mistake however they are spelled, and
+ * the workspace root itself is not a package root — with no `packages` every
+ * file already imports through the workspace alias, and a root holding every
+ * path would also hold every bare module specifier. Roots may nest: a nested
+ * root is a subpath export of the package around it.
+ */
+export const modulePackages = v.pipe(v.array(modulePackage), v.rawCheck(({ dataset, addIssue }) => {
+    if (!dataset.typed)
+        return;
+    const seen = new Map();
+    for (const { rootPath } of dataset.value) {
+        const canonical = toWorkspacePath(rootPath);
+        const previous = seen.get(canonical);
+        if (canonical === '') {
+            addIssue({
+                message: `package rootPath '${rootPath}' is the workspace root — a package root is a folder ` +
+                    `below basePath; leave packages unset to import everything through '@/' from basePath`
+            });
+        }
+        else if (previous !== undefined) {
+            addIssue({
+                message: `package rootPath '${rootPath}' is already listed as '${previous}' — ` +
+                    `each package root appears once; roots may nest, but not repeat`
+            });
+        }
+        seen.set(canonical, rootPath);
+    }
+}));
 /**
  * Valibot schema for validating skip paths configuration.
  *
@@ -144,7 +177,7 @@ export const anchorsSettings = v.object({
 export const clientSettings = v.object({
     basePath: v.optional(v.string()),
     schemaSource: v.optional(v.string()),
-    packages: v.optional(v.array(modulePackage)),
+    packages: v.optional(modulePackages),
     enrichments: v.optional(generatorEnrichments),
     include: v.optional(v.array(include)),
     skip: v.optional(v.array(skip)),

package/esm/types/SkmtcDocument.d.ts

@@ -78,4 +78,3 @@ export type SkmtcDocumentInput = {
     type: 'gql';
     value: string | GraphQLSchema;
 };
-//# sourceMappingURL=SkmtcDocument.d.ts.map

package/esm/types/SupportedSubjects.d.ts

@@ -38,4 +38,3 @@ export type GeneratorSupport = {
 };
 /** Generator id → the subjects that generator supports. */
 export type SupportedSubjects = Record<string, GeneratorSupport>;
-//# sourceMappingURL=SupportedSubjects.d.ts.map

package/esm/types/TypeSystem.d.ts

@@ -567,4 +567,3 @@ export type TypeSystemArgs<Schema extends SchemaType> = {
  * ```
  */
 export type SchemaToValueFn = <Schema extends SchemaType>(args: TypeSystemArgs<Schema>) => TypeSystemOutput<Schema['type']>;
-//# sourceMappingURL=TypeSystem.d.ts.map

package/esm/types/Variant.d.ts

@@ -62,4 +62,3 @@ export type Variant = string;
  * kebab → PascalCase transform invertible.
  */
 export declare const variantNameRegex: RegExp;
-//# sourceMappingURL=Variant.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmtc/core",
-  "version": "0.28.4",
+  "version": "0.28.6",
   "description": "Skmtc is a declarative code generation framework",
   "keywords": [
     "openapi",
@@ -9,7 +9,7 @@
     "codegen",
     "code generator"
   ],
-  "homepage": "https://skm.tc",
+  "homepage": "https://skmtc.dev",
   "repository": {
     "type": "git",
     "url": "https://github.com/skmtc/skmtc.git"
@@ -223,5 +223,5 @@
     "openapi-types": "12.1.3",
     "valibot": "1.1.0"
   },
-  "_generatedBy": "dnt@dev"
+  "_generatedBy": "dnt@0.43.2"
 }

package/script/_dnt.polyfills.d.ts

@@ -4,4 +4,102 @@ declare global {
     }
 }
 export {};
-//# sourceMappingURL=_dnt.polyfills.d.ts.map
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;

package/script/_dnt.polyfills.js

@@ -1,2 +1,133 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.import_meta_ponyfill = exports.import_meta_ponyfill_esmodule = exports.import_meta_ponyfill_commonjs = void 0;
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+const node_module_1 = require("node:module");
+//@ts-ignore
+const node_url_1 = require("node:url");
+//@ts-ignore
+const node_path_1 = require("node:path");
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+exports.import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: (0, node_url_1.pathToFileURL)(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return (0, node_url_1.pathToFileURL)((importMeta.url === parentURL
+                            ? require
+                            : (0, node_module_1.createRequire)(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", exports.import_meta_ponyfill_commonjs);
+exports.import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + process.argv[1].replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = (0, node_url_1.fileURLToPath)(importMeta.url);
+                importMeta.dirname = (0, node_path_1.dirname)(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            exports.import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: (0, node_module_1.createRequire)(importMeta.url),
+                    };
+                    // note: the parameter types must be explicitly annotated because
+                    // `@types/node` also declares `ImportMeta.resolve`, which makes
+                    // the contextual type an overload set that provides no inference
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return (0, node_url_1.pathToFileURL)((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : (0, node_module_1.createRequire)(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            exports.import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return (0, exports.import_meta_ponyfill_esmodule)(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", exports.import_meta_ponyfill_esmodule);
+exports.import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        exports.import_meta_ponyfill = (r, m) => (0, exports.import_meta_ponyfill_commonjs)(r, m);
+    }
+    else {
+        //@ts-ignore
+        exports.import_meta_ponyfill = (im) => (0, exports.import_meta_ponyfill_esmodule)(im);
+    }
+    //@ts-ignore
+    return (0, exports.import_meta_ponyfill)(...args);
+});

package/script/_dnt.shims.d.ts

@@ -3,4 +3,3 @@ export { Deno } from "@deno/shim-deno";
 export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
     Deno: typeof Deno;
 };
-//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/anchors/CaptureSink.d.ts

@@ -80,4 +80,3 @@ export declare class CaptureSink {
      */
     observe(producer: SnippetBase, impl: (this: SnippetBase) => string): string;
 }
-//# sourceMappingURL=CaptureSink.d.ts.map

package/script/anchors/ParserAdapter.d.ts

@@ -92,4 +92,3 @@ export interface ParserAdapter {
         end: number;
     };
 }
-//# sourceMappingURL=ParserAdapter.d.ts.map

package/script/anchors/attribute.d.ts

@@ -22,4 +22,3 @@ import type { Attribution } from './types.js';
  * key-derived fallback pointer.
  */
 export declare const attribute: (producer: SnippetBase) => Attribution;
-//# sourceMappingURL=attribute.d.ts.map

package/script/anchors/attribute.js

@@ -58,7 +58,9 @@ exports.attribute = attribute;
  * - OAS operation → `#/paths/<escaped-path>/<method>`
  * - GQL operation → `<rootKind>.<fieldName>`
  * - Model → `#/components/schemas/<refName>`
- * - Generator-only / no key → `''` (no schema location to point at)
+ * - Container / generator-only / no key → `''` (no schema location to point
+ *   at — a container is a place many subjects insert into, so it has no
+ *   position of its own; its MEMBERS carry their subjects' keys)
  */
 const schemaPointerFromKey = (parsed) => {
     if (!parsed)
@@ -72,6 +74,7 @@ const schemaPointerFromKey = (parsed) => {
             return `${parsed.rootKind}.${parsed.fieldName}`;
         case 'model':
             return `#/components/schemas/${parsed.refName}`;
+        case 'container':
         case 'generator-only':
             return '';
         default: {

package/script/anchors/buildSidecar.d.ts

@@ -51,4 +51,3 @@ export type BuildSidecarArgs = {
  * export and have no useful re-resolution path (plan #25).
  */
 export declare const buildSidecar: ({ filePath, schemaSrc, parser, anchors }: BuildSidecarArgs) => Sidecar;
-//# sourceMappingURL=buildSidecar.d.ts.map

package/script/anchors/generationMap.d.ts

@@ -64,4 +64,3 @@ export declare const toNdjson: (entries: readonly GenerationMapEntry[]) => strin
  * unparseable means the file is corrupt, not just stale.
  */
 export declare const parseNdjson: (text: string) => GenerationMapEntry[];
-//# sourceMappingURL=generationMap.d.ts.map

package/script/anchors/postPass.d.ts

@@ -84,4 +84,3 @@ export type PostPassArgs = {
  * disk, attach to manifest, send over the wire).
  */
 export declare const postPass: ({ filePath, source, spans, schemaSrc, parser, generatorMeta }: PostPassArgs) => Sidecar;
-//# sourceMappingURL=postPass.d.ts.map