typekro 0.43.0 → 0.44.1

package/dist/core/validation/structural-spec-dependence.d.ts

@@ -1,179 +0,0 @@
-/**
- * Structural spec-dependence diagnostics.
- *
- * ## The rule
- *
- * A `ResourceGraphDefinition` is fixed at build time. `schema.spec.*` values
- * are *runtime* references: KRO substitutes them per instance, long after the
- * composition function has run. So a spec value may decide what a field
- * **contains** (a value position), but it may never decide what the graph
- * **looks like** — which resources exist, how many list entries there are, or
- * what an object's keys are called (a structural position).
- *
- * When a composition puts a spec value in a structural position, the
- * composition function still runs: the schema proxy hands the author a
- * `KubernetesRef` and JavaScript does something plausible-but-wrong with it.
- * An `if` takes the truthy branch because a proxy object is truthy. A `.map()`
- * runs exactly once against a sentinel element. `Object.keys()` yields one
- * fabricated key. The RGD that comes out is well-formed and silently encodes
- * the build-time guess for every instance.
- *
- * This module turns that silence into a KRO-mode serialization error.
- *
- * ## What is detected
- *
- * Two independent detectors, deliberately narrow so that legitimate
- * value-position uses (`replicas: spec.replicas`, `` url: `http://${spec.host}` ``,
- * CEL ternaries in status) stay silent:
- *
- * 1. {@link scanRgdResourcesForStructuralSpecArtifacts} — reads the RGD that is
- *    about to be emitted and reports build-time residue that can only come from
- *    a structural use. This is evidence-based: every finding is a concrete
- *    artifact in the output, so there are no false positives by construction.
- *      - `spec-derived-key`: an object key (or resource id) that is a schema
- *        reference marker — `{ [spec.key]: v }`, or `Object.fromEntries(...)`
- *        over a spec collection.
- *      - `runtime-map-enumerated`: the `__typekroSchemaKey` sentinel, which the
- *        schema proxy hands out when a composition enumerates a
- *        `Record<string, V>` spec field (`Object.keys(spec.settings)`,
- *        `{ ...spec.settings }`) whose keys are not knowable until runtime.
- *      - `collection-length-collapsed`: a `$item` element sentinel surviving in
- *        a resource that carries no `forEach` dimension — a `.map()` / `for-of`
- *        over a spec collection that was flattened to a single element instead
- *        of being compiled to KRO's `forEach`. A backstop: the serializer
- *        normally rewrites `$item` either into a `forEach` loop variable or
- *        into a whole-array reference (`ports: ${schema.spec.ports}`), both of
- *        which are correct, so this catches only what those miss.
- *
- * 2. {@link detectStructuralSpecPredicates} — parses the composition source and
- *    reports branch predicates that are spec-derived in a form the control-flow
- *    analyzer cannot compile to `includeWhen`, so the branch was decided at
- *    build time:
- *      - `uncompiled-predicate`: the `if` / ternary test reaches the spec only
- *        through a local binding (`const enabled = spec.enabled; if (enabled)`,
- *        `const { enabled } = spec;`), so the analyzer's lexical `spec` check
- *        misses it and no `includeWhen` is attached.
- *      - `switch-discriminator`: a `switch` on a spec-derived discriminant.
- *        There is no `switch` lowering at all; the proxy matches no `case`, so
- *        `default` wins for every instance.
- *      - `collection-length-read`: `.length` on a spec-derived collection or
- *        string. The proxy always answers `1`, so the value is a build-time
- *        constant no matter what the instance holds.
- *
- *    A branch only counts when it BUILDS something. That question is settled
- *    by an allowlist, not by the callee's name: nothing in the source says
- *    whether an imported binding is a factory, and casing least of all — most
- *    of this repo's factories are camelCase (`helmRelease`, `serviceAccount`,
- *    `persistentVolumeClaim`, `observedResource`, `singleton`). So any call in
- *    the branch counts as building structure unless it is a pure JavaScript
- *    builtin (`String(…)`, `JSON.stringify(…)`, `Math.max(…)`, `items.map(…)`)
- *    or a `Cel.*` runtime expression. See {@link isPureHelperCall}.
- *
- * ## What is NOT detected
- *
- * Static analysis of arbitrary JavaScript cannot be complete, and this check
- * does not pretend otherwise. Known blind spots:
- *
- *   - A predicate laundered through a **helper function** or a module-level
- *     constant: `if (isEnabled(spec))`. The alias resolver only walks
- *     top-level `const`/`let` bindings in the composition body.
- *   - A predicate on a value read back **out of a resource** rather than off
- *     the spec proxy.
- *   - Structure decided by a spec value that is **consumed by a factory** and
- *     collapsed inside it, if the collapse leaves no marker, sentinel or
- *     `$item` residue in the emitted RGD.
- *   - A branch whose only call is a **method named like a builtin**
- *     (`registry.push(…)`, `catalog.map(…)`): the pure-helper allowlist matches
- *     on the method name without resolving the receiver, so such a call is
- *     assumed pure. No factory in `src/factories/**` carries one of those
- *     names, and a new one must not.
- *   - Anything reached through `eval`, dynamic imports, or a composition whose
- *     source cannot be parsed (the AST detector degrades to silence, never to
- *     a false positive).
- *
- * Detector 1 is the backstop for most of these: however the structure was
- * decided, if the decision left residue in the RGD it is reported.
- */
-import { TypeKroError } from '../errors.js';
-import type { KroResourceTemplate } from '../types/serialization.js';
-/** How a runtime spec value ended up deciding build-time structure. */
-export type StructuralSpecDependenceKind = 'spec-derived-key' | 'runtime-map-enumerated' | 'collection-length-collapsed' | 'uncompiled-predicate' | 'switch-discriminator' | 'collection-length-read';
-/** One place where graph structure was decided by a runtime spec value. */
-export interface StructuralSpecDependenceFinding {
-    readonly kind: StructuralSpecDependenceKind;
-    /**
-     * Where the dependence surfaced: a resource id, or `resource.<id>` plus the
-     * dotted path inside its template, or a source excerpt for AST findings.
-     */
-    readonly location: string;
-    /** Spec paths involved, as `spec.<path>` (may be empty when unresolvable). */
-    readonly specPaths: readonly string[];
-    /** One sentence naming what the emitted RGD actually encodes. */
-    readonly detail: string;
-}
-/**
- * A place where the composition read the keys of a spec field at build time.
- * A candidate for a `runtime-map-enumerated` finding, not a finding itself.
- */
-export interface MapEnumerationSite {
-    /** Source excerpt, e.g. `Object.keys(spec.settings)` or `...spec.app.env`. */
-    readonly location: string;
-    /** The `spec.<path>` whose keys were read. */
-    readonly specPath: string;
-}
-/** Thrown when a KRO-mode RGD would silently encode a build-time guess. */
-export declare class StructuralSpecDependenceError extends TypeKroError {
-    readonly graphName: string;
-    readonly findings: readonly StructuralSpecDependenceFinding[];
-    constructor(message: string, graphName: string, findings: readonly StructuralSpecDependenceFinding[]);
-}
-/**
- * Report build-time residue in the RGD that is about to be emitted.
- *
- * Operates on the serialized manifest rather than on live composition state,
- * so every finding is backed by a concrete artifact in the output.
- */
-export declare function scanRgdResourcesForStructuralSpecArtifacts(resources: readonly KroResourceTemplate[]): StructuralSpecDependenceFinding[];
-/**
- * Branch predicates and `.length` reads the control-flow analyzer does not
- * compile. See {@link analyzeCompositionSource}.
- */
-export declare function detectStructuralSpecPredicates(compositionSource: string | undefined): StructuralSpecDependenceFinding[];
-/**
- * Sites where the composition reads the keys of a spec field at build time.
- *
- * These are CANDIDATES, never findings. Enumerating an *object-typed* spec
- * field is legitimate — the schema proxy is shape-aware and yields the real
- * declared names — and the AST cannot tell that apart from a map-typed field,
- * whose keys exist only per instance. Only the emitted RGD can, by leaving the
- * `__typekroSchemaKey` sentinel behind; but that sentinel carries no path when
- * it was consumed as a plain string. Reporting these alongside such a finding
- * lets the message point at the lines worth reading without claiming any one
- * of them is the culprit.
- */
-export declare function detectMapEnumerationSites(compositionSource: string | undefined): readonly MapEnumerationSite[];
-/** Render the diagnostic text shared by the error and the escape-hatch warning. */
-export declare function formatStructuralSpecDependence(graphName: string, findings: readonly StructuralSpecDependenceFinding[], mapEnumerationSites?: readonly MapEnumerationSite[]): string;
-/**
- * Whether the structural spec-dependence check ignores per-composition escape
- * hatches.
- *
- * `TYPEKRO_STRUCTURAL_SPEC=strict` makes every structural use an error even
- * when the composition sets `allowStructuralSpecDependence`, so a repository
- * can audit what its shipped graphs still depend on without editing them.
- * Resolved in ONE place, matching `isStrictCelDiagnosticsEnabled`.
- */
-export declare function isStructuralSpecDependenceStrict(): boolean;
-/**
- * Gate KRO-mode serialization on structural spec-dependence.
- *
- * Throws {@link StructuralSpecDependenceError} unless `allow` is set, in which
- * case the same report is logged as a warning naming every path.
- */
-export declare function assertNoStructuralSpecDependence(input: {
-    graphName: string;
-    resources: readonly KroResourceTemplate[];
-    compositionSource?: string | undefined;
-    allow?: boolean | undefined;
-}): void;
-//# sourceMappingURL=structural-spec-dependence.d.ts.map

package/dist/core/validation/structural-spec-dependence.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"structural-spec-dependence.d.ts","sourceRoot":"","sources":["../../../src/core/validation/structural-spec-dependence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AA0BrE,uEAAuE;AACvE,MAAM,MAAM,4BAA4B,GACpC,kBAAkB,GAClB,wBAAwB,GACxB,6BAA6B,GAC7B,sBAAsB,GACtB,sBAAsB,GACtB,wBAAwB,CAAC;AAE7B,2EAA2E;AAC3E,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAOD,2EAA2E;AAC3E,qBAAa,6BAA8B,SAAQ,YAAY;aAG3C,SAAS,EAAE,MAAM;aACjB,QAAQ,EAAE,SAAS,+BAA+B,EAAE;gBAFpE,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,SAAS,+BAA+B,EAAE;CAKvE;AA4DD;;;;;GAKG;AACH,wBAAgB,0CAA0C,CACxD,SAAS,EAAE,SAAS,mBAAmB,EAAE,GACxC,+BAA+B,EAAE,CAoFnC;AAmjBD;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACpC,+BAA+B,EAAE,CAEnC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACpC,SAAS,kBAAkB,EAAE,CAE/B;AAuCD,mFAAmF;AACnF,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,SAAS,+BAA+B,EAAE,EACpD,mBAAmB,GAAE,SAAS,kBAAkB,EAAO,GACtD,MAAM,CAkCR;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,IAAI,OAAO,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B,GAAG,IAAI,CA2BP"}

package/dist/factories/cert-manager/utils/helm-values-mapper.d.ts

@@ -1,23 +0,0 @@
-import type { CertManagerBootstrapConfig, CertManagerHelmValues } from '../types.js';
-/**
- * Maps CertManagerBootstrapConfig to cert-manager Helm values
- *
- * This function transforms the TypeKro configuration interface into the format
- * expected by the official cert-manager Helm chart.
- *
- * @param config - The cert-manager bootstrap configuration
- * @returns Helm values object for the cert-manager chart
- */
-export declare function mapCertManagerConfigToHelmValues(config: CertManagerBootstrapConfig): CertManagerHelmValues;
-/**
- * Checks cert-manager Helm values for best-practice warnings (e.g., HA, monitoring).
- *
- * Unlike {@link validateCertManagerHelmValues} (in `resources/helm.ts`) which performs
- * hard validation (invalid replica counts, wrong resource types), this function
- * returns advisory warnings about sub-optimal but technically valid configurations.
- *
- * @param values - The Helm values to check
- * @returns Array of warning messages (empty if no issues found)
- */
-export declare function getCertManagerHelmValueWarnings(values: CertManagerHelmValues): string[];
-//# sourceMappingURL=helm-values-mapper.d.ts.map

package/dist/factories/cert-manager/utils/helm-values-mapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helm-values-mapper.d.ts","sourceRoot":"","sources":["../../../../src/factories/cert-manager/utils/helm-values-mapper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAErF;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,0BAA0B,GACjC,qBAAqB,CAqFvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,EAAE,CAuCvF"}

package/dist/factories/cert-manager/utils/index.d.ts

@@ -1,2 +0,0 @@
-export { getCertManagerHelmValueWarnings, mapCertManagerConfigToHelmValues, } from './helm-values-mapper.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/factories/cert-manager/utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/factories/cert-manager/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,gCAAgC,GACjC,MAAM,yBAAyB,CAAC"}

package/dist/factories/flux/kustomize/types.d.ts

@@ -1,2 +0,0 @@
-export type { KustomizationSpec, KustomizationStatus, } from '../../../core/types/yaml.js';
-//# sourceMappingURL=types.d.ts.map

package/dist/factories/flux/kustomize/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/factories/flux/kustomize/types.ts"],"names":[],"mappings":"AACA,YAAY,EACV,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,6BAA6B,CAAC"}

package/dist/factories/nats/compositions/nack-controller-migration.d.ts

@@ -1,18 +0,0 @@
-import type { KubernetesObjectApi } from '@kubernetes/client-node';
-export interface LegacyNackRetirementOptions {
-    readonly namespace: string;
-    readonly instanceName: string;
-    readonly kubernetesApi: KubernetesObjectApi;
-    readonly timeout?: number;
-    readonly abortSignal?: AbortSignal;
-}
-/**
- * Retire the v0.33.5 instance-owned NACK HelmRelease after the replacement
- * singleton is Ready.
- *
- * This is intentionally ownership- and UID-leased. A same-named user release,
- * a release belonging to another TypeKro instance, or a replacement object
- * appearing during deletion is never adopted or deleted.
- */
-export declare function retireLegacyNackController(options: LegacyNackRetirementOptions): Promise<void>;
-//# sourceMappingURL=nack-controller-migration.d.ts.map

package/dist/factories/nats/compositions/nack-controller-migration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nack-controller-migration.d.ts","sourceRoot":"","sources":["../../../../src/factories/nats/compositions/nack-controller-migration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AASrF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,mBAAmB,CAAC;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CAkEf"}

package/dist/factories/ory/schemas/maester-crds.d.ts

@@ -1,9 +0,0 @@
-/**
- * Ory Maester CRD contract umbrella exports for chart version 0.62.0.
- *
- * Hydra Maester `OAuth2Client` contracts live in `hydra-maester.ts`.
- * Oathkeeper Maester `Rule` contracts live in `oathkeeper-maester.ts`.
- */
-export type * from './hydra-maester.js';
-export type * from './oathkeeper-maester.js';
-//# sourceMappingURL=maester-crds.d.ts.map

package/dist/factories/ory/schemas/maester-crds.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"maester-crds.d.ts","sourceRoot":"","sources":["../../../../src/factories/ory/schemas/maester-crds.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,mBAAmB,oBAAoB,CAAC;AACxC,mBAAmB,yBAAyB,CAAC"}

package/dist/factories/pebble/utils/helm-values-mapper.d.ts

@@ -1,21 +0,0 @@
-/**
- * Pebble Helm Values Mapper
- *
- * Maps TypeKro Pebble configuration to Helm chart values format.
- * This ensures compatibility with the JupyterHub Pebble Helm chart structure.
- */
-import type { PebbleBootstrapConfig, PebbleHelmValues } from '../types.js';
-/**
- * Maps PebbleBootstrapConfig to Helm chart values format
- *
- * @param config - TypeKro Pebble configuration
- * @returns Helm chart values compatible with JupyterHub Pebble chart
- */
-export declare function mapPebbleConfigToHelmValues(config: PebbleBootstrapConfig): PebbleHelmValues;
-/**
- * Creates default Pebble configuration optimized for testing
- *
- * @returns Default Pebble Helm values for fast testing
- */
-export declare function createDefaultPebbleTestingValues(): PebbleHelmValues;
-//# sourceMappingURL=helm-values-mapper.d.ts.map

package/dist/factories/pebble/utils/helm-values-mapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helm-values-mapper.d.ts","sourceRoot":"","sources":["../../../../src/factories/pebble/utils/helm-values-mapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAmD3F;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,IAAI,gBAAgB,CA+BnE"}

package/dist/factories/shared.d.ts

@@ -1,18 +0,0 @@
-/**
- * Shared utilities for factory functions
- *
- * This module re-exports the core proxy engine (`createResource`) and
- * composition context infrastructure for backward compatibility with
- * existing factory consumers.
- *
- * The canonical implementations live in:
- * - Proxy engine: `src/core/proxy/create-resource.ts`
- * - Composition context: `src/core/composition/context.ts`
- */
-import type { CompositionContext, CompositionContextOptions } from '../core/composition/context.js';
-import { createCompositionContext, getCurrentCompositionContext, registerDeploymentClosure, runInStatusBuilderContext, runWithCompositionContext } from '../core/composition/context.js';
-export type { CompositionContext, CompositionContextOptions };
-export { createCompositionContext, getCurrentCompositionContext, registerDeploymentClosure, runInStatusBuilderContext, runWithCompositionContext, };
-export type { CreateResourceOptions } from '../core/proxy/create-resource.js';
-export { createResource } from '../core/proxy/create-resource.js';
-//# sourceMappingURL=shared.d.ts.map

package/dist/factories/shared.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/factories/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AACpG,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,gCAAgC,CAAC;AAGxC,YAAY,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,CAAC;AAC9D,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,GAC1B,CAAC;AAEF,YAAY,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAE9E,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/shared/own-property.d.ts

@@ -1,15 +0,0 @@
-/**
- * Own-property assignment for objects rebuilt from arbitrary keys.
- *
- * `target[key] = value` is not a plain write when `key` is `'__proto__'`: on
- * an ordinary object it runs the inherited prototype setter, so the key never
- * becomes a property and silently disappears from the rebuilt object. Data
- * whose keys come from a caller (a map of setting names, Helm values, labels)
- * can legitimately contain it, so every helper that copies such data key by
- * key assigns through {@link setOwnProperty}.
- *
- * Every other key is assigned exactly as before, so the rebuilt object keeps
- * its ordinary prototype and nothing else about it changes.
- */
-export declare function setOwnProperty(target: object, key: string, value: unknown): void;
-//# sourceMappingURL=own-property.d.ts.map

package/dist/shared/own-property.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"own-property.d.ts","sourceRoot":"","sources":["../../src/shared/own-property.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAWhF"}

package/dist/utils/cel-escape.d.ts

@@ -1,12 +0,0 @@
-/**
- * Escape a string for safe embedding inside a CEL string literal.
- *
- * Handles backslash, double-quote, newline, carriage return, and tab.
- * Must be used everywhere we embed literal text in CEL output.
- *
- * This is the **single source of truth** for CEL string escaping —
- * all modules that need to produce CEL string literals should import
- * from here rather than maintaining inline copies.
- */
-export declare function escapeCelString(value: string): string;
-//# sourceMappingURL=cel-escape.d.ts.map

package/dist/utils/cel-escape.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cel-escape.d.ts","sourceRoot":"","sources":["../../src/utils/cel-escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOrD"}

package/dist/utils/cel-resource-identifiers.d.ts

@@ -1,23 +0,0 @@
-export interface CelRootReference {
-    readonly root: string;
-    readonly segments: readonly string[];
-    readonly startOffset: number;
-    readonly endOffset: number;
-}
-/**
- * Parse CEL and return root identifier references, memoized by source text.
- *
- * Nested-composition resolution revisits stable expressions many times. Caching at this shared
- * analysis boundary ensures syntax-aware consumers pay the parser cost once without coupling the
- * cache to any particular serializer recursion strategy.
- */
-export declare function celRootReferences(expression: string): readonly CelRootReference[];
-/**
- * Extract resource references embedded in TypeKro's string-coercion marker format.
- */
-export declare function kubernetesMarkerReferences(value: string): readonly Pick<CelRootReference, 'root' | 'segments'>[];
-/**
- * Canonicalize resource roots in executable CEL while preserving literals and lambda bindings.
- */
-export declare function canonicalizeCelResourceAliases(expression: string, aliases: ReadonlyMap<string, string>): string;
-//# sourceMappingURL=cel-resource-identifiers.d.ts.map

package/dist/utils/cel-resource-identifiers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cel-resource-identifiers.d.ts","sourceRoot":"","sources":["../../src/utils/cel-resource-identifiers.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAgPD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAWjF;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,GACZ,SAAS,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,UAAU,CAAC,EAAE,CASxD;AA+CD;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,MAAM,CA+BR"}