@intentius/chant 0.7.0 → 0.8.0

package/dist/serializer.d.ts

@@ -0,0 +1,64 @@
+import type { Declarable } from "./declarable.js";
+import type { LexiconOutput } from "./lexicon-output.js";
+import type { OwnershipMarker } from "./ownership.js";
+/**
+ * Build-time context passed to a serializer. Optional — serializers that don't
+ * need it ignore the parameter.
+ */
+export interface SerializeContext {
+    /**
+     * When set, the serializer stamps this ownership marker into the target's
+     * native metadata channel (AWS/Azure tags, K8s/GCP labels).
+     */
+    ownership?: OwnershipMarker;
+    /**
+     * The resolved project configuration, when a build was driven from a project
+     * with a `chant.config.*`. Lets a serializer read its own lexicon-scoped
+     * settings (e.g. the forgejo dialect's `forgejo.runnerLabels`). Undefined for
+     * ad-hoc builds (e.g. context tools) that pass no config.
+     */
+    config?: Record<string, unknown>;
+}
+/**
+ * Result of serialization that may include additional files (e.g. nested stack templates).
+ */
+export interface SerializerResult {
+    /** Primary template content */
+    primary: string;
+    /** Additional files keyed by filename (e.g. "network.template.json" → content) */
+    files?: Record<string, string>;
+    /**
+     * Non-fatal diagnostics produced during serialization (e.g. a dialect
+     * dropping keys the target platform ignores). The build pipeline collects
+     * these into its `warnings` array.
+     */
+    warnings?: string[];
+}
+/**
+ * Serializer interface for chant specifications
+ */
+export interface Serializer {
+    /**
+     * Name of the lexicon
+     */
+    name: string;
+    /**
+     * Prefix used for rules in this lexicon
+     */
+    rulePrefix: string;
+    /**
+     * Serializes the entities to a string representation
+     * @param entities - Map of entity name to Declarable entity
+     * @param outputs - Optional array of LexiconOutputs produced by this lexicon
+     * @param context - Optional build-time context (e.g. ownership marker)
+     */
+    serialize(entities: Map<string, Declarable>, outputs?: LexiconOutput[], context?: SerializeContext): string | SerializerResult;
+    /**
+     * Serialize a cross-lexicon reference to a foreign output.
+     * Called when this lexicon consumes an output produced by another lexicon.
+     * @param output - The LexiconOutput being referenced
+     * @returns Lexicon-specific reference representation
+     */
+    serializeCrossRef?(output: LexiconOutput): unknown;
+}
+//# sourceMappingURL=serializer.d.ts.map

package/dist/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;;OAKG;IACH,SAAS,CACP,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EACjC,OAAO,CAAC,EAAE,aAAa,EAAE,EACzB,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,GAAG,gBAAgB,CAAC;IAE7B;;;;;OAKG;IACH,iBAAiB,CAAC,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC;CACpD"}

package/dist/sort.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Performs a topological sort on a dependency graph
+ * @param dependencies - Record where keys are entity names and values are arrays of their dependencies
+ * @returns Array of entity names in topological order (dependencies appear before dependents)
+ * @throws {BuildError} If a cycle is detected in the dependency graph
+ */
+export declare function topologicalSort(dependencies: Record<string, string[]>): string[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../src/sort.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACrC,MAAM,EAAE,CA8CV"}

package/dist/stack-output.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Stack Output — marks a value for cross-stack export.
+ *
+ * When a child project declares `stackOutput(ref)`, the serializer emits
+ * it into the template's Outputs section. The parent can then reference
+ * it via `nestedStack().outputs.name`.
+ */
+import { DECLARABLE_MARKER, type Declarable } from "./declarable.js";
+import type { AttrRef } from "./attrref.js";
+/**
+ * Marker symbol for stack output identification.
+ */
+export declare const STACK_OUTPUT_MARKER: unique symbol;
+/**
+ * A stack output declaration — wraps an AttrRef into a Declarable
+ * that serializers emit as a template Output.
+ */
+export interface StackOutput extends Declarable {
+    readonly [STACK_OUTPUT_MARKER]: true;
+    readonly [DECLARABLE_MARKER]: true;
+    readonly lexicon: string;
+    readonly entityType: string;
+    readonly kind: "output";
+    readonly sourceRef: AttrRef;
+    readonly description?: string;
+}
+/**
+ * Type guard for StackOutput.
+ */
+export declare function isStackOutput(value: unknown): value is StackOutput;
+/**
+ * Create a stack output that exports an attribute reference for cross-stack use.
+ *
+ * @param ref - The AttrRef to export (e.g. `vpc.vpcId`)
+ * @param options - Optional description for the output
+ * @returns A StackOutput Declarable
+ *
+ * @example
+ * ```ts
+ * import { stackOutput } from "@intentius/chant";
+ * import { vpc, subnet } from "./vpc";
+ *
+ * export const vpcId = stackOutput(vpc.vpcId);
+ * export const subnetId = stackOutput(subnet.subnetId, {
+ *   description: "Primary subnet ID",
+ * });
+ * ```
+ */
+export declare function stackOutput(ref: AttrRef, options?: {
+    description?: string;
+}): StackOutput;
+//# sourceMappingURL=stack-output.d.ts.map

package/dist/stack-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-output.d.ts","sourceRoot":"","sources":["../src/stack-output.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,mBAAmB,eAAkC,CAAC;AAEnE;;;GAGG;AACH,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,IAAI,CAAC;IACrC,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAOlE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,EACZ,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC,WAAW,CAkBb"}

package/dist/toml-emit.d.ts

@@ -0,0 +1,22 @@
+/**
+ * TOML emitter.
+ *
+ * Converts JavaScript objects to TOML document strings.
+ * Handles scalars, tables, arrays, array of tables, and inline tables.
+ */
+export interface EmitTOMLOptions {
+    /** Comment to prepend at the top of the document. */
+    header?: string;
+    /** Key ordering hint: keys matching earlier entries appear first. */
+    keyOrder?: string[];
+}
+/**
+ * Emit a JavaScript object as a TOML document string.
+ *
+ * - Top-level scalars, arrays of scalars → bare key-value pairs.
+ * - Nested objects → `[section]` tables.
+ * - Arrays of objects → `[[section]]` array of tables.
+ * - Deeply nested objects → `[parent.child]` dotted sections.
+ */
+export declare function emitTOML(value: unknown, options?: EmitTOMLOptions): string;
+//# sourceMappingURL=toml-emit.d.ts.map

package/dist/toml-emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toml-emit.d.ts","sourceRoot":"","sources":["../src/toml-emit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,eAAe;IAC9B,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM,CAsB1E"}

package/dist/toml-parse.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TOML parser.
+ *
+ * Handles the TOML subset used by Chant lexicons: tables, arrays of tables,
+ * key-value pairs, inline tables, inline arrays, strings, numbers, booleans.
+ */
+/**
+ * Parse a TOML document string into a plain object.
+ *
+ * Uses a built-in parser that handles the common TOML subset used by tool
+ * configuration files (tables, dotted keys, inline tables, and arrays).
+ */
+export declare function parseTOML(content: string): Record<string, unknown>;
+//# sourceMappingURL=toml-parse.d.ts.map

package/dist/toml-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toml-parse.d.ts","sourceRoot":"","sources":["../src/toml-parse.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8ClE"}

package/dist/toml-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared TOML utilities — key escaping, string unescaping, etc.
+ */
+/**
+ * Escape a TOML key if it contains special characters.
+ */
+export declare function escapeKey(key: string): string;
+/**
+ * Unescape a TOML basic string.
+ */
+export declare function unescapeString(val: string): string;
+/**
+ * Sort keys according to a preferred order, with unmatched keys at the end.
+ */
+export declare function sortKeys(keys: string[], keyOrder?: string[]): string[];
+/**
+ * Strip inline comment from a value string.
+ */
+export declare function stripInlineComment(raw: string): string;
+//# sourceMappingURL=toml-utils.d.ts.map

package/dist/toml-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toml-utils.d.ts","sourceRoot":"","sources":["../src/toml-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOlD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAStE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAkBtD"}

package/dist/toml.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TOML emitter and parser — re-exports from split modules.
+ *
+ * Import from here for the public API:
+ *   import { emitTOML, parseTOML } from "@intentius/chant/toml";
+ */
+export { emitTOML, type EmitTOMLOptions } from "./toml-emit.js";
+export { parseTOML } from "./toml-parse.js";
+//# sourceMappingURL=toml.d.ts.map

package/dist/toml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toml.d.ts","sourceRoot":"","sources":["../src/toml.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,47 @@
+import type { Intrinsic } from "./intrinsic.js";
+/**
+ * Value type that can be either a concrete value T or an Intrinsic
+ */
+export type Value<T> = T | Intrinsic;
+/**
+ * Converts all properties of T to Value<T> types
+ *
+ * @example
+ * ```ts
+ * interface Props { name: string; count: number }
+ * type ValueProps = AllValues<Props>
+ * // Result: { name: Value<string>; count: Value<number> }
+ * ```
+ */
+export type AllValues<T> = {
+    [K in keyof T]: Value<T[K]>;
+};
+/**
+ * Makes specific properties K of T be Value types while keeping others unchanged
+ *
+ * @example
+ * ```ts
+ * interface Props { name: string; count: number; enabled: boolean }
+ * type ValueProps = PartialValues<Props, 'name' | 'count'>
+ * // Result: { name: Value<string>; count: Value<number>; enabled: boolean }
+ * ```
+ */
+export type PartialValues<T, K extends keyof T> = {
+    [P in keyof T]: P extends K ? Value<T[P]> : T[P];
+};
+/**
+ * Makes specific properties K of T required while keeping others unchanged
+ *
+ * @example
+ * ```ts
+ * interface Props { name?: string; count?: number; enabled?: boolean }
+ * type RequiredNameProps = RequiredProps<Props, 'name'>
+ * // Result: { name: string; count?: number; enabled?: boolean }
+ * ```
+ */
+type Prettify<T> = {
+    [P in keyof T]: T[P];
+} & {};
+export type RequiredProps<T, K extends keyof T> = Prettify<Omit<T, K> & Required<Pick<T, K>>>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;GAEG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;AAErC;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;KACxB,CAAC,IAAI,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI;KAC/C,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACjD,CAAC;AAEF;;;;;;;;;GASG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,EAAE,CAAC;AACjD,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/utils.d.ts

@@ -0,0 +1,30 @@
+import type { Declarable } from "./declarable.js";
+import { AttrRef } from "./attrref.js";
+/**
+ * Symbol for storing logical names on Declarable entities
+ */
+export declare const LOGICAL_NAME_SYMBOL: unique symbol;
+/**
+ * Duck-type check for AttrRef that survives the dual-package hazard.
+ * When npm installs separate copies of @intentius/chant (one for the CLI,
+ * one for the lexicon), `instanceof AttrRef` fails across package boundaries.
+ */
+export declare function isAttrRefLike(value: unknown): value is AttrRef;
+/**
+ * JSON.stringify replacer that sorts object keys for deterministic output.
+ */
+export declare function sortedJsonReplacer(_key: string, value: unknown): unknown;
+/**
+ * Get all property names that have AttrRef values
+ * @param entity - The declarable entity to inspect
+ * @returns Array of property names with AttrRef values
+ */
+export declare function getAttributes(entity: Declarable): string[];
+/**
+ * Get the logical name stored on a Declarable entity
+ * @param entity - The declarable entity
+ * @returns The logical name
+ * @throws {Error} If logical name is not set
+ */
+export declare function getLogicalName(entity: Declarable): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,mBAAmB,eAAkC,CAAC;AAEnE;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAW9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAOxE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAc1D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAUzD"}

package/dist/validation.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Validation system for declarable entities
+ *
+ * Provides opt-in, non-blocking validation hooks that can be used
+ * to validate entities during build or discovery phases.
+ */
+import type { Declarable } from "./declarable.js";
+/**
+ * Result of a validation check
+ */
+export interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Error message if validation failed */
+    message?: string;
+    /** Optional additional context about the validation */
+    context?: Record<string, unknown>;
+}
+/**
+ * A validation rule that can check declarable entities
+ */
+export interface ValidationRule {
+    /** Unique identifier for this rule */
+    id: string;
+    /** Human-readable description of what this rule checks */
+    description: string;
+    /** Validate an entity and return result */
+    validate(entity: Declarable): ValidationResult;
+}
+/**
+ * Validate an entity against a set of validation rules
+ *
+ * This function is opt-in and non-blocking - it returns results
+ * but does not throw errors. Callers can decide how to handle
+ * validation failures.
+ *
+ * @param entity - The declarable entity to validate
+ * @param rules - Array of validation rules to apply
+ * @returns Array of validation results, one per rule
+ */
+export declare function validate(entity: Declarable, rules: ValidationRule[]): ValidationResult[];
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB,CAAC;CAChD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,cAAc,EAAE,GACtB,gBAAgB,EAAE,CAEpB"}

package/dist/yaml.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Lightweight YAML emitter and parser.
+ *
+ * Covers the subset of YAML used by Chant lexicons (scalars, block arrays,
+ * nested objects, tagged values). Not a full YAML implementation — use a
+ * dedicated library if you need anchors, multi-document streams, or
+ * block scalars.
+ */
+/**
+ * Emit a YAML value with proper indentation.
+ *
+ * - Primitives render inline.
+ * - Arrays and objects render as block YAML, returning a string that starts
+ *   with `\n` so the caller can append it after a key.
+ * - Tagged values `{ tag, value }` emit `!tag [...]` or `!tag scalar`.
+ */
+export declare function emitYAML(value: unknown, indent: number): string;
+/** Result of parsing a YAML block. */
+export interface ParseResult {
+    value: unknown;
+    endIndex: number;
+}
+/**
+ * Parse a YAML document (or JSON document) into a plain object.
+ *
+ * Tries `JSON.parse` first; falls back to a line-based YAML parser that
+ * handles the subset of YAML commonly found in CI configuration files.
+ */
+export declare function parseYAML(content: string): Record<string, unknown>;
+/**
+ * Parse indentation-based YAML lines into a key-value object.
+ */
+export declare function parseYAMLLines(lines: string[], startIndex: number, baseIndent: number): ParseResult;
+/**
+ * Parse a block array (lines starting with `- `).
+ */
+export declare function parseYAMLArray(lines: string[], startIndex: number, baseIndent: number): ParseResult;
+/**
+ * Coerce a scalar string to a typed value.
+ */
+export declare function parseScalar(value: string): unknown;
+//# sourceMappingURL=yaml.d.ts.map

package/dist/yaml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../src/yaml.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CA2G/D;AAMD,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASlE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAuEb;AAsDD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAkEb;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAelD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -24,6 +24,7 @@
   "type": "module",
   "files": [
     "src/",
+    "dist/",
     "bin/"
   ],
   "publishConfig": {
@@ -33,11 +34,35 @@
     "chant": "./bin/chant"
   },
   "exports": {
-    ".": "./src/index.ts",
-    "./cli": "./src/cli/index.ts",
-    "./cli/*": "./src/cli/*.ts",
-    "./op": "./src/op/index.ts",
-    "./*": "./src/*.ts"
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./src/index.ts"
+    },
+    "./cli": {
+      "development": "./src/cli/index.ts",
+      "types": "./dist/cli/index.d.ts",
+      "default": "./src/cli/index.ts"
+    },
+    "./cli/*": {
+      "development": "./src/cli/*.ts",
+      "types": "./dist/cli/*.d.ts",
+      "default": "./src/cli/*.ts"
+    },
+    "./op": {
+      "development": "./src/op/index.ts",
+      "types": "./dist/op/index.d.ts",
+      "default": "./src/op/index.ts"
+    },
+    "./*": {
+      "development": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && find dist -type f \\( -name \"*.js\" -o -name \"*.js.map\" \\) -delete",
+    "prepack": "npm run build"
   },
   "dependencies": {
     "fflate": "^0.8.2",

package/src/audit/bundle-decoupling.test.ts

@@ -0,0 +1,56 @@
+import { describe, test, expect } from "vitest";
+import { build } from "esbuild";
+import { fileURLToPath } from "url";
+
+/**
+ * #408: importing the audit core must NOT statically pull in `cli/plugins`
+ * (which drags in the config loader and the TypeScript compiler — fatal on edge
+ * runtimes). `loadPlugins` is reached only via a lazy `import()` inside
+ * `load()`, so with code splitting `cli/plugins` lands in a separate chunk and
+ * never in the entry chunk that an embedder bundles.
+ */
+async function entryInputsFor(file: string): Promise<{ entryInputs: string[]; allInputs: string[] }> {
+  const result = await build({
+    entryPoints: [fileURLToPath(new URL(file, import.meta.url))],
+    bundle: true,
+    format: "esm",
+    splitting: true,
+    platform: "node",
+    // Skip node_modules (incl. the huge `typescript` package) — we only care
+    // about which internal modules land in the entry chunk.
+    packages: "external",
+    metafile: true,
+    write: false,
+    outdir: "out",
+    logLevel: "silent",
+  });
+  const outputs = result.metafile.outputs;
+  const entry = Object.values(outputs).find((o) => o.entryPoint?.endsWith(file.replace("./", "audit/")));
+  return {
+    entryInputs: entry ? Object.keys(entry.inputs) : [],
+    allInputs: Object.values(outputs).flatMap((o) => Object.keys(o.inputs)),
+  };
+}
+
+/**
+ * #408/#426: importing the audit entry points must NOT statically pull in
+ * `cli/plugins` — it drags the config loader and the root barrel (index.ts ->
+ * lint/parser -> the TypeScript compiler), fatal on edge runtimes. `loadPlugins`
+ * / `loadPlugin` are reached only via lazy `import()`, so with code splitting
+ * `cli/plugins` lands in a separate chunk, never the entry an embedder bundles.
+ */
+describe("audit bundle graph (edge-safe entries)", () => {
+  test("audit/core (auditFiles) does not statically import cli/plugins", async () => {
+    const { entryInputs, allInputs } = await entryInputsFor("./core.ts");
+    expect(entryInputs.length, "core.ts entry chunk present").toBeGreaterThan(0);
+    expect(entryInputs.some((p) => p.includes("cli/plugins"))).toBe(false);
+    // Still reachable, just split into its own chunk (lazy, not dropped).
+    expect(allInputs.some((p) => p.includes("cli/plugins"))).toBe(true);
+  }, 30_000);
+
+  test("audit/discover (classifyFiles) does not statically import cli/plugins", async () => {
+    const { entryInputs } = await entryInputsFor("./discover.ts");
+    expect(entryInputs.length, "discover.ts entry chunk present").toBeGreaterThan(0);
+    expect(entryInputs.some((p) => p.includes("cli/plugins"))).toBe(false);
+  }, 30_000);
+});

package/src/audit/catalog.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "vitest";
-import { RULE_CATALOG, ruleMeta } from "./catalog";
+import { RULE_CATALOG, RULE_CATEGORY, ruleMeta } from "./catalog";
 import { loadPlugins } from "../cli/plugins";
 
 /** All post-synth check ids the audit can actually surface, from the lexicons. */
@@ -34,6 +34,21 @@ describe("RULE_CATALOG", () => {
       expect(m.remediation.length, `${id} has remediation`).toBeGreaterThan(0);
       expect(["merge-worthy", "report-only"]).toContain(m.tier);
       expect(["deterministic", "guidance"]).toContain(m.fixKind);
+      expect(["security", "correctness", "best-practice"], `${id} has a valid category`).toContain(m.category);
+    }
+  });
+
+  test("every entry is categorized from the curated map (no fallback)", () => {
+    // meta() falls back to "best-practice" only if RULE_CATEGORY is missing an
+    // id — assert the curated map explicitly covers every catalogued rule, so a
+    // new rule can't silently inherit the fallback.
+    const uncategorized = Object.keys(RULE_CATALOG).filter((id) => !(id in RULE_CATEGORY)).sort();
+    expect(uncategorized, "rules missing an explicit RULE_CATEGORY entry").toEqual([]);
+    // And an authority citation (the strongest signal) always means security.
+    for (const [id, m] of Object.entries(RULE_CATALOG)) {
+      if (m.authority && m.authority.length > 0) {
+        expect(m.category, `${id} cites an authority, so it is security`).toBe("security");
+      }
     }
   });