@skmtc/core 0.0.984 → 0.16.2

package/esm/types/Enrichments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Enrichments.d.ts","sourceRoot":"","sources":["../../src/types/Enrichments.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Enrichments.d.ts","sourceRoot":"","sources":["../../src/types/Enrichments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,sBAAsB,CAAC;AAG9B,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAA;AAEpC;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAE7D,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,aAAa,CAAC,gBAAgB,CAAqC,CAAA;AAEpG;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAEjE,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,aAAa,CAAC,oBAAoB,CAGtE,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;AAErE,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,aAAa,CAAC,kBAAkB,CAGlE,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAEhE,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,aAAa,CAAC,mBAAmB,CAGpE,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;AAExE,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,aAAa,CAAC,sBAAsB,CAG1E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,WAAW,CAAA;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,eAAe,CAAA;AAEpD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAAI,KAAK,MAAM,KAAG,OAA8B,CAAA;AAEpF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CACvC,MAAM,EACN,gBAAgB,GAAG,kBAAkB,GAAG,sBAAsB,CAC/D,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,aAAa,CAAC,oBAAoB,CAiCtE,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,WAAW,CAAC,OAAO,GAAG,SAAS,EAAE,SAAS,GAAG,SAAS,EAAE,KAAK,GAAG,SAAS,IAAI;IACvF,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;IACpB,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAK5F,CAAA;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/esm/types/Enrichments.js

@@ -1,149 +1,115 @@
 /**
- * @fileoverview Enrichment System for SKMTC Core
- *
- * This module provides comprehensive enrichment types and schemas for enhancing
- * OpenAPI operations with UI generation metadata. Enrichments allow generators
- * to create forms, tables, inputs, and other UI components with rich metadata
- * about how data should be presented and interacted with.
- *
- * The enrichment system supports a hierarchical structure:
- * Generator → Path → Method → Operation → Component Type (form/table/input)
- *
- * ## Key Features
- *
- * - **Form Enrichments**: Field definitions with inputs, labels, and validation
- * - **Table Enrichments**: Column definitions with formatters and headers
- * - **Input Enrichments**: Standalone input components with formatting
- * - **Hierarchical Organization**: Nested structure for easy lookup and management
- * - **Type Safety**: Comprehensive Valibot validation for all enrichment data
- *
- * @example Basic form enrichment
- * ```typescript
- * import type { FormItem } from '@skmtc/core/Enrichments';
- *
- * const userForm: FormItem = {
- *   title: 'User Registration',
- *   description: 'Create a new user account',
- *   fields: [
- *     {
- *       id: 'name',
- *       accessorPath: ['name'],
- *       input: { moduleName: 'TextInput', exportName: 'default' },
- *       label: 'Full Name',
- *       placeholder: 'Enter your full name'
- *     }
- *   ],
- *   submitLabel: 'Create Account'
- * };
- * ```
- *
- * @example Table enrichment with formatters
- * ```typescript
- * import type { TableItem } from '@skmtc/core/Enrichments';
- *
- * const userTable: TableItem = {
- *   title: 'User Directory',
- *   columns: [
- *     {
- *       id: 'email',
- *       accessorPath: ['email'],
- *       formatter: { moduleName: 'EmailFormatter', exportName: 'default' },
- *       label: 'Email Address'
- *     }
- *   ]
- * };
+ * @fileoverview Enrichment hierarchy for SKMTC Core.
+ *
+ * Core owns only the lookup *hierarchy* — the keys that locate an
+ * enrichment payload for a generator + operation/model:
+ *
+ *   - **Models** are keyed by name (component schema name in OAS;
+ *     registry-named type in GraphQL).
+ *   - **OAS operations** are keyed by HTTP path → method.
+ *   - **GraphQL operations** are keyed by root kind → field name.
+ *
+ * The leaf at the bottom of each hierarchy is opaque to core — its
+ * shape is owned by the generator that consumes it. Each generator
+ * declares its own enrichment schema via the `toEnrichmentSchema`
+ * configuration on its entry factory; the dispatcher parses the
+ * generator's slice of the enrichments record through that schema
+ * before handing typed enrichments to `transform`.
+ *
+ * This means **no leaf shapes live in core**. A generator adding a
+ * new enrichment field is a purely local change — no coordinated
+ * core update, no canonical schema to extend. Two generators with
+ * different needs at the same operation can declare different leaf
+ * shapes and they don't collide.
+ *
+ * @example A generator declaring its own leaf shape
+ * ```ts
+ * // gen-myform/src/enrichments.ts
+ * import * as v from 'valibot'
+ *
+ * const enrichmentSchema = v.optional(v.object({
+ *   title: v.optional(v.string()),
+ *   submitLabel: v.optional(v.string()),
+ *   fields: v.optional(v.array(v.object({
+ *     id: v.string(),
+ *     label: v.optional(v.string())
+ *   })))
+ * }))
+ *
+ * export type EnrichmentSchema = v.InferOutput<typeof enrichmentSchema>
+ * export const toEnrichmentSchema = () => enrichmentSchema
  * ```
  *
  * @module Enrichments
  */
-import { moduleExport } from './ModuleExport.js';
+import "../_dnt.polyfills.js";
 import * as v from 'valibot';
+export const modelEnrichments = v.record(v.string(), v.unknown());
+export const oasMethodEnrichments = v.record(v.string(), v.unknown());
+export const oasPathEnrichments = v.record(v.string(), oasMethodEnrichments);
+export const gqlFieldEnrichments = v.record(v.string(), v.unknown());
+export const gqlRootKindEnrichments = v.record(v.string(), gqlFieldEnrichments);
 /**
- * Valibot schema for form field items.
- *
- * Validates individual form field configurations including input components,
- * labels, placeholders, and data access paths.
+ * Reserved enrichment key for the **stack** scope. Lives at the top
+ * level of the enrichments record (a sibling of the generator-id keys);
+ * its value is a single leaf shared across every generator in the
+ * composition. Read via `toStackEnrichment(context, schema)`.
  */
-export const formFieldItem = v.object({
-    id: v.string(),
-    accessorPath: v.array(v.string()),
-    input: moduleExport,
-    label: v.string(),
-    placeholder: v.optional(v.string())
-});
+export const STACK_ENRICHMENT_KEY = '_stack';
 /**
- * Valibot schema for form configurations.
- *
- * Validates complete form definitions including title, description,
- * field configurations, and submit button labels.
+ * Reserved enrichment key for the **generator** scope. Lives inside a
+ * generator's slot (a sibling of the subject keys); its value is a
+ * run-constant leaf for that one generator. Read via
+ * `toGeneratorEnrichment(context, id, schema)`.
  */
-export const formItem = v.object({
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    fields: v.optional(v.array(formFieldItem)),
-    submitLabel: v.optional(v.string())
-});
+export const GENERATOR_ENRICHMENT_KEY = '_generator';
 /**
- * Valibot schema for table column items.
- *
- * Validates table column configurations including formatter components,
- * labels, and data access paths.
+ * Whether an enrichment key is **engine-reserved** rather than
+ * customer-defined. Every reserved key is `_`-prefixed; customer keys
+ * (generator ids, subject names) must not be. This single predicate is
+ * the source of truth for every iteration site that must skip reserved
+ * keys — generators never iterate enrichments themselves (they read by
+ * known key through the typed helpers), so the segregation is a core /
+ * migration concern only.
  */
-export const tableColumnItem = v.object({
-    id: v.string(),
-    accessorPath: v.array(v.string()),
-    formatter: moduleExport,
-    label: v.string()
-});
+export const isReservedEnrichmentKey = (key) => key.startsWith('_');
+export const generatorEnrichments = v.pipe(v.record(v.string(), v.union([modelEnrichments, oasPathEnrichments, gqlRootKindEnrichments])), v.rawCheck(({ dataset, addIssue }) => {
+    if (!dataset.typed)
+        return;
+    for (const [topKey, slot] of Object.entries(dataset.value)) {
+        if (isReservedEnrichmentKey(topKey)) {
+            if (topKey !== STACK_ENRICHMENT_KEY) {
+                addIssue({
+                    message: `Enrichment key '${topKey}' starts with '_' but is not a recognised reserved key. ` +
+                        `The only reserved top-level key is '${STACK_ENRICHMENT_KEY}' (stack enrichment); ` +
+                        `generator ids must not start with '_'.`
+                });
+            }
+            // `_stack`'s value is a leaf — nothing to validate inside it.
+            continue;
+        }
+        if (typeof slot !== 'object' || slot === null)
+            continue;
+        for (const slotKey of Object.keys(slot)) {
+            if (isReservedEnrichmentKey(slotKey) && slotKey !== GENERATOR_ENRICHMENT_KEY) {
+                addIssue({
+                    message: `Enrichment key '${slotKey}' under generator '${topKey}' starts with '_' but is not ` +
+                        `a recognised reserved key. The only reserved per-generator key is ` +
+                        `'${GENERATOR_ENRICHMENT_KEY}' (generator enrichment); subject keys must not start with '_'.`
+                });
+            }
+        }
+    }
+}));
 /**
- * Valibot schema for table configurations.
- *
- * Validates complete table definitions including title, description,
- * and column configurations.
+ * The composite enrichment schema a generator with NO enrichments at any scope
+ * declares (`toEnrichmentSchema: () => emptyEnrichmentSchema`). Every member is
+ * `v.undefined()` — strict: a no-enrichment generator that somehow receives a
+ * value fails loud (fail-open at the call site) rather than silently swallowing
+ * it.
  */
-export const tableItem = v.object({
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    columns: v.optional(v.array(tableColumnItem))
+export const emptyEnrichmentSchema = v.object({
+    subject: v.undefined(),
+    generator: v.undefined(),
+    stack: v.undefined()
 });
-/**
- * Valibot schema for input items.
- *
- * Validates input component configurations including formatter components
- * and data access paths.
- */
-export const inputItem = v.object({
-    id: v.string(),
-    accessorPath: v.array(v.string()),
-    formatter: moduleExport
-});
-/**
- * Valibot schema for operation-level enrichments.
- *
- * Validates enrichment configurations that can be applied to OpenAPI operations,
- * including table, form, and input component definitions.
- */
-export const operationEnrichments = v.object({
-    table: v.optional(tableItem),
-    form: v.optional(formItem),
-    input: v.optional(inputItem)
-});
-/**
- * Valibot schema for HTTP method-level enrichments.
- *
- * Maps HTTP methods (GET, POST, etc.) to their operation enrichment configurations.
- */
-export const methodEnrichments = v.record(v.string(), operationEnrichments);
-/**
- * Valibot schema for API path-level enrichments.
- *
- * Maps API paths to their method enrichment configurations.
- */
-export const pathEnrichments = v.record(v.string(), methodEnrichments);
-/**
- * Valibot schema for generator-level enrichments.
- *
- * Maps generator IDs to their path enrichment configurations,
- * creating a complete hierarchy of enrichment data.
- */
-export const generatorEnrichments = v.record(v.string(), pathEnrichments);

package/esm/types/GeneratorType.d.ts

@@ -1,127 +1,65 @@
-import type { OperationConfig } from '../dsl/operation/types.js';
+import type { OasOperationConfig } from '../dsl/operation/oas/types.js';
+import type { WebhookConfig } from '../dsl/webhook/types.js';
+import type { GqlOperationConfig } from '../dsl/operation/gql/types.js';
 import type { ModelConfig } from '../dsl/model/types.js';
 /**
- * Union type representing all possible generator configurations.
+ * Discriminated union of every generator configuration the dispatcher
+ * recognizes. The `type` field discriminates the variant — `'oasOperation'`
+ * for HTTP-flavored operation generators, `'gqlOperation'` for GraphQL
+ * operation generators, `'model'` for protocol-neutral model generators.
  *
- * Generator configurations define how different types of generators should
- * process OpenAPI documents. This includes both operation generators (which
- * process API endpoints) and model generators (which process data schemas).
+ * Operation variants are routed only to the matching document protocol; a
+ * `'oasOperation'` config is silently skipped on a GraphQL document and
+ * vice versa. Model generators run against either protocol's registry.
  *
  * @template EnrichmentType - Optional type for custom enrichment data
  *
- * @example
+ * @example OAS operation generator
  * ```typescript
- * import { GeneratorConfig } from '@skmtc/core';
+ * import { toOasOperationEntry } from '@skmtc/core';
  *
- * // Operation generator configuration
- * const apiClientConfig: GeneratorConfig = {
- *   type: 'operation',
- *   generatorId: 'api-client',
- *   settings: {
- *     exportPath: './src/api/client.ts',
- *     enrichment: customEnrichments
- *   },
- *   toGenerator: (args) => new ApiClientGenerator(args)
- * };
- *
- * // Model generator configuration
- * const typescriptModels: GeneratorConfig = {
- *   type: 'model',
- *   generatorId: 'typescript-models',
- *   settings: {
- *     exportPath: './src/types/models.ts'
- *   },
- *   toGenerator: (args) => new TypeScriptModelGenerator(args)
- * };
- * ```
- */
-export type GeneratorConfig<EnrichmentType = undefined> = OperationConfig<EnrichmentType> | ModelConfig<EnrichmentType>;
-/**
- * Type-safe mapping of generator configurations.
- *
- * This type preserves the structure and types of generator configurations
- * within a map, ensuring that each generator maintains its specific
- * configuration type and enrichment data.
- *
- * @template G - The generator configuration type
- * @template EnrichmentType - The enrichment type for the generators
- *
- * @example
- * ```typescript
- * type MyGenerators = {
- *   'api-client': OperationConfig<ApiEnrichment>;
- *   'typescript-models': ModelConfig<ModelEnrichment>;
- *   'validation': ModelConfig<ValidationEnrichment>;
- * };
- *
- * type MyGeneratorsMap = GeneratorsMap<MyGenerators, undefined>;
- * // Preserves the exact structure and types of MyGenerators
+ * const apiClientEntry = toOasOperationEntry({
+ *   id: 'api-client',
+ *   transform: ({ context, operation }) => {},
+ *   isSupported: ({ operation }) => operation.method === 'get'
+ * });
+ * // apiClientEntry.type === 'oasOperation'
  * ```
- */
-export type GeneratorsMap<G extends GeneratorConfig<EnrichmentType>, EnrichmentType> = {
-    [K in keyof G]: G[K];
-};
-/**
- * Container type for a complete generators map with optional enrichment.
- *
- * This type represents a complete mapping of generators that can process
- * an OpenAPI document. It's used as the main configuration structure
- * passed to the SKMTC processing pipeline.
- *
- * @template EnrichmentType - Optional type for custom enrichment data across all generators
  *
- * @example Basic generators map
+ * @example GraphQL operation generator
  * ```typescript
- * import { GeneratorsMapContainer } from '@skmtc/core';
+ * import { toGqlOperationEntry } from '@skmtc/core';
  *
- * const generators: GeneratorsMapContainer = {
- *   'api-client': {
- *     type: 'operation',
- *     generatorId: 'api-client',
- *     settings: { exportPath: './src/api.ts' },
- *     toGenerator: (args) => new ApiClientGenerator(args)
- *   },
- *   'typescript-models': {
- *     type: 'model',
- *     generatorId: 'typescript-models',
- *     settings: { exportPath: './src/models.ts' },
- *     toGenerator: (args) => new TypeScriptModels(args)
- *   }
- * };
- *
- * // Use with toArtifacts
- * const result = await toArtifacts({
- *   documentObject: openApiDoc,
- *   settings: clientSettings,
- *   toGeneratorConfigMap: () => generators,
- *   traceId: 'generation',
- *   spanId: 'main',
- *   startAt: Date.now()
+ * const gqlEntry = toGqlOperationEntry({
+ *   id: 'gql-client',
+ *   transform: ({ context, operation }) => {}
  * });
+ * // gqlEntry.type === 'gqlOperation'
  * ```
  *
- * @example With enrichments
+ * @example Model generator
  * ```typescript
- * type MyEnrichments = {
- *   customValidation: boolean;
- *   generateComments: boolean;
- * };
+ * import { toModelEntry } from '@skmtc/core';
  *
- * const enrichedGenerators: GeneratorsMapContainer<MyEnrichments> = {
- *   'enhanced-models': {
- *     type: 'model',
- *     generatorId: 'enhanced-models',
- *     settings: {
- *       exportPath: './src/enhanced.ts',
- *       enrichment: {
- *         customValidation: true,
- *         generateComments: true
- *       }
- *     },
- *     toGenerator: (args) => new EnhancedModelGenerator(args)
- *   }
- * };
+ * const modelEntry = toModelEntry({
+ *   id: 'typescript-models',
+ *   transform: ({ context, refName }) => {}
+ * });
+ * // modelEntry.type === 'model'
  * ```
  */
-export type GeneratorsMapContainer<EnrichmentType = undefined> = GeneratorsMap<GeneratorConfig<EnrichmentType>, EnrichmentType>;
+export type GeneratorConfig<EnrichmentType = undefined> = OasOperationConfig<EnrichmentType> | WebhookConfig<EnrichmentType> | GqlOperationConfig<EnrichmentType> | ModelConfig<EnrichmentType>;
+/**
+ * A name → generator-config map. Keys are arbitrary generator
+ * identifiers (the same string a caller might pass to `--skip` etc.);
+ * each value is a `GeneratorConfig` variant.
+ *
+ * The runtime treats this as a plain `Record<string, GeneratorConfig>`
+ * — it iterates with `Object.values` and `Object.keys` — so the type
+ * mirrors that shape. There is no per-key type narrowing: callers who
+ * want type-level distinctions between specific entries can keep the
+ * literal map well-typed at its definition site and only widen here at
+ * the boundary.
+ */
+export type GeneratorsMapContainer<EnrichmentType = undefined> = Record<string, GeneratorConfig<EnrichmentType>>;
 //# sourceMappingURL=GeneratorType.d.ts.map

package/esm/types/GeneratorType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeneratorType.d.ts","sourceRoot":"","sources":["../../src/types/GeneratorType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,eAAe,CAAC,cAAc,GAAG,SAAS,IAClD,eAAe,CAAC,cAAc,CAAC,GAC/B,WAAW,CAAC,cAAc,CAAC,CAAA;AAE/B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,eAAe,CAAC,cAAc,CAAC,EAAE,cAAc,IAAI;KACpF,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,MAAM,MAAM,sBAAsB,CAAC,cAAc,GAAG,SAAS,IAAI,aAAa,CAC5E,eAAe,CAAC,cAAc,CAAC,EAC/B,cAAc,CACf,CAAA"}
+{"version":3,"file":"GeneratorType.d.ts","sourceRoot":"","sources":["../../src/types/GeneratorType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,MAAM,eAAe,CAAC,cAAc,GAAG,SAAS,IAClD,kBAAkB,CAAC,cAAc,CAAC,GAClC,aAAa,CAAC,cAAc,CAAC,GAC7B,kBAAkB,CAAC,cAAc,CAAC,GAClC,WAAW,CAAC,cAAc,CAAC,CAAA;AAE/B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,sBAAsB,CAAC,cAAc,GAAG,SAAS,IAAI,MAAM,CACrE,MAAM,EACN,eAAe,CAAC,cAAc,CAAC,CAChC,CAAA"}

package/esm/types/JsonPointer.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview RFC 6901 JSON Pointer branded type and helpers.
+ *
+ * Used by gen-maps (the attribution / sidecar system) to identify
+ * the precise location of a schema element within the OpenAPI
+ * document. Threaded through parse via `StackTrail.toJsonPointer()`
+ * and attached to every parsed OAS schema as `.location`.
+ *
+ * @module JsonPointer
+ */
+import type { Brand } from './Brand.js';
+/**
+ * Branded type for an RFC 6901 JSON Pointer string.
+ *
+ * Always starts with `#/` (URI fragment form) or `/` (raw form);
+ * helpers in this module produce the URI fragment form so the
+ * resulting strings round-trip through the `oas:` URI scheme used
+ * in sidecar `S` tables.
+ *
+ * Empty pointer (`#/`) refers to the document root.
+ */
+export type JsonPointer = Brand<string, 'JsonPointer'>;
+/**
+ * Escape a single segment per RFC 6901 §4.
+ *
+ * `~` → `~0` (must be replaced first to avoid double-escaping)
+ * `/` → `~1`
+ */
+export declare const escapeSegment: (segment: string) => string;
+/**
+ * Unescape a single segment per RFC 6901 §4.
+ *
+ * `~1` → `/` (must be replaced first)
+ * `~0` → `~`
+ */
+export declare const unescapeSegment: (segment: string) => string;
+/**
+ * Build a JSON Pointer from an array of unescaped segments.
+ * Returns the URI fragment form: `#/<seg1>/<seg2>/...`.
+ *
+ * Empty array yields `#/` (document root).
+ *
+ * @example
+ * ```ts
+ * toJsonPointer(['components', 'schemas', 'User'])
+ * // → '#/components/schemas/User'
+ *
+ * toJsonPointer(['paths', '/users/{id}', 'get'])
+ * // → '#/paths/~1users~1{id}/get'
+ * ```
+ */
+export declare const toJsonPointer: (segments: readonly string[]) => JsonPointer;
+/**
+ * Parse a JSON Pointer (URI fragment form `#/...` or raw `/...`)
+ * into an array of unescaped segments.
+ *
+ * Returns `undefined` if the pointer is malformed (doesn't start
+ * with `#/` or `/`, or is empty).
+ *
+ * @example
+ * ```ts
+ * fromJsonPointer('#/components/schemas/User')
+ * // → ['components', 'schemas', 'User']
+ *
+ * fromJsonPointer('#/paths/~1users~1{id}/get')
+ * // → ['paths', '/users/{id}', 'get']
+ *
+ * fromJsonPointer('#/')
+ * // → []
+ * ```
+ */
+export declare const fromJsonPointer: (pointer: string) => string[] | undefined;
+/**
+ * Append one or more segments to an existing JSON Pointer.
+ *
+ * @example
+ * ```ts
+ * const base = toJsonPointer(['components', 'schemas', 'User'])
+ * append(base, 'properties', 'email')
+ * // → '#/components/schemas/User/properties/email'
+ * ```
+ */
+export declare const append: (pointer: JsonPointer, ...segments: string[]) => JsonPointer;
+/**
+ * Type guard for the URI-fragment form.
+ *
+ * Loose check — verifies prefix and that there are no obviously
+ * malformed sequences. Doesn't verify that all `~` instances are
+ * 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/JsonPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonPointer.d.ts","sourceRoot":"","sources":["../../src/types/JsonPointer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,MACK,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MACG,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU,SAAS,MAAM,EAAE,KAAG,WAG3D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MAAM,EAAE,GAAG,SAa5D,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,WAAW,EAAE,GAAG,UAAU,MAAM,EAAE,KAAG,WAOpE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAGvD,CAAA"}

package/esm/types/JsonPointer.js

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview RFC 6901 JSON Pointer branded type and helpers.
+ *
+ * Used by gen-maps (the attribution / sidecar system) to identify
+ * the precise location of a schema element within the OpenAPI
+ * document. Threaded through parse via `StackTrail.toJsonPointer()`
+ * and attached to every parsed OAS schema as `.location`.
+ *
+ * @module JsonPointer
+ */
+/**
+ * Escape a single segment per RFC 6901 §4.
+ *
+ * `~` → `~0` (must be replaced first to avoid double-escaping)
+ * `/` → `~1`
+ */
+export const escapeSegment = (segment) => segment.replaceAll('~', '~0').replaceAll('/', '~1');
+/**
+ * Unescape a single segment per RFC 6901 §4.
+ *
+ * `~1` → `/` (must be replaced first)
+ * `~0` → `~`
+ */
+export const unescapeSegment = (segment) => segment.replaceAll('~1', '/').replaceAll('~0', '~');
+/**
+ * Build a JSON Pointer from an array of unescaped segments.
+ * Returns the URI fragment form: `#/<seg1>/<seg2>/...`.
+ *
+ * Empty array yields `#/` (document root).
+ *
+ * @example
+ * ```ts
+ * toJsonPointer(['components', 'schemas', 'User'])
+ * // → '#/components/schemas/User'
+ *
+ * toJsonPointer(['paths', '/users/{id}', 'get'])
+ * // → '#/paths/~1users~1{id}/get'
+ * ```
+ */
+export const toJsonPointer = (segments) => {
+    if (segments.length === 0)
+        return '#/';
+    return `#/${segments.map(escapeSegment).join('/')}`;
+};
+/**
+ * Parse a JSON Pointer (URI fragment form `#/...` or raw `/...`)
+ * into an array of unescaped segments.
+ *
+ * Returns `undefined` if the pointer is malformed (doesn't start
+ * with `#/` or `/`, or is empty).
+ *
+ * @example
+ * ```ts
+ * fromJsonPointer('#/components/schemas/User')
+ * // → ['components', 'schemas', 'User']
+ *
+ * fromJsonPointer('#/paths/~1users~1{id}/get')
+ * // → ['paths', '/users/{id}', 'get']
+ *
+ * fromJsonPointer('#/')
+ * // → []
+ * ```
+ */
+export const fromJsonPointer = (pointer) => {
+    let body;
+    if (pointer.startsWith('#/')) {
+        body = pointer.slice(2);
+    }
+    else if (pointer.startsWith('/')) {
+        body = pointer.slice(1);
+    }
+    else if (pointer === '#' || pointer === '') {
+        return [];
+    }
+    else {
+        return undefined;
+    }
+    if (body === '')
+        return [];
+    return body.split('/').map(unescapeSegment);
+};
+/**
+ * Append one or more segments to an existing JSON Pointer.
+ *
+ * @example
+ * ```ts
+ * const base = toJsonPointer(['components', 'schemas', 'User'])
+ * append(base, 'properties', 'email')
+ * // → '#/components/schemas/User/properties/email'
+ * ```
+ */
+export const append = (pointer, ...segments) => {
+    if (segments.length === 0)
+        return pointer;
+    const escaped = segments.map(escapeSegment).join('/');
+    if (pointer === '#/') {
+        return `#/${escaped}`;
+    }
+    return `${pointer}/${escaped}`;
+};
+/**
+ * Type guard for the URI-fragment form.
+ *
+ * Loose check — verifies prefix and that there are no obviously
+ * malformed sequences. Doesn't verify that all `~` instances are
+ * followed by `0` or `1` (a stricter validator could).
+ */
+export const isJsonPointer = (value) => {
+    if (typeof value !== 'string')
+        return false;
+    return value === '#/' || value.startsWith('#/');
+};