@intentius/chant 0.7.0 → 0.8.1

package/dist/import/parser.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Intermediate representation of a template parameter
+ */
+export interface ParameterIR {
+    readonly name: string;
+    readonly type: string;
+    readonly description?: string;
+    readonly defaultValue?: unknown;
+    readonly required?: boolean;
+}
+/**
+ * Intermediate representation of a template resource
+ */
+export interface ResourceIR {
+    readonly logicalId: string;
+    readonly type: string;
+    readonly properties: Record<string, unknown>;
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Intermediate representation of a parsed template
+ */
+export interface TemplateIR {
+    readonly resources: ResourceIR[];
+    readonly parameters: ParameterIR[];
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Interface for template parsers that convert external formats to IR
+ */
+export interface TemplateParser {
+    /**
+     * Parse template content into intermediate representation
+     * @param content - Raw template content (JSON, YAML, etc.)
+     * @returns Intermediate representation of the template
+     */
+    parse(content: string): TemplateIR;
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/import/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/import/parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,EAAE,UAAU,EAAE,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;CACpC"}

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * chant Core
+ *
+ * Lexicon-agnostic declarative specification system
+ */
+export * from "./declarable.js";
+export * from "./composite.js";
+export * from "./provenance.js";
+export * from "./intrinsic.js";
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./attrref.js";
+export * from "./utils.js";
+export * from "./builder.js";
+export * from "./serializer.js";
+export * from "./lexicon-output.js";
+export * from "./discovery/files.js";
+export * from "./discovery/import.js";
+export * from "./discovery/collect.js";
+export * from "./discovery/cycles.js";
+export * from "./sort.js";
+export * from "./discovery/resolve.js";
+export * from "./discovery/graph.js";
+export * from "./discovery/index.js";
+export * from "./discovery/cache.js";
+export * from "./build.js";
+export * from "./detectLexicon.js";
+export * from "./lint/parser.js";
+export * from "./lint/rule.js";
+export * from "./lint/rules/index.js";
+export * from "./lint/declarative.js";
+export * from "./lint/selectors.js";
+export * from "./lint/named-checks.js";
+export * from "./lint/post-synth.js";
+export * from "./lint/policy.js";
+export * from "./lint/rule-loader.js";
+export * from "./lint/discover.js";
+export * from "./import/parser.js";
+export * from "./import/generator.js";
+export * from "./lexicon.js";
+export * from "./lexicon-integrity.js";
+export * from "./lexicon-manifest.js";
+export * from "./lexicon-schema.js";
+export * from "./config.js";
+export * from "./validation.js";
+export * from "./project-validation.js";
+export * from "./codegen/naming.js";
+export * from "./codegen/fetch.js";
+export * from "./codegen/generate.js";
+export * from "./codegen/package.js";
+export * from "./codegen/typecheck.js";
+export * from "./codegen/coverage.js";
+export * from "./codegen/validate.js";
+export * from "./codegen/docs.js";
+export * from "./runtime.js";
+export * from "./runtime-adapter.js";
+export * from "./resource-attributes.js";
+export * from "./stack-output.js";
+export * from "./child-project.js";
+export * from "./lsp/types.js";
+export * from "./lsp/lexicon-providers.js";
+export * from "./mcp/types.js";
+export * from "./lifecycle/index.js";
+export { Op, phase, activity, gate, kubectlApply, helmInstall, waitForStack, gitlabPipeline, lifecycleSnapshot, shell, teardown, OpResource } from "./op/index.js";
+export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep } from "./op/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,QAAQ,CAAC;AACvB,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAElC,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAClE,cAAc,EAAE,iBAAiB,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC5F,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/intrinsic-interpolation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tagged template interpolation helper.
+ *
+ * Implements the lockstep walk over tagged template literal parts/values,
+ * dispatching on AttrRef / Intrinsic / Declarable / primitive.
+ * Each lexicon provides format-specific serialization strings.
+ */
+export type InterpolationValueSerializer = (value: unknown) => string;
+/**
+ * Default serialization dispatch for interpolated values.
+ *
+ * Handles: AttrRef → Intrinsic (with Ref special case) → Declarable (throws) → primitive.
+ * Lexicons can wrap/extend this for format-specific behavior.
+ *
+ * @param serializeAttrRef - Format an AttrRef: (logicalName, attribute) → string
+ * @param serializeRef - Format a Ref intrinsic: (refName) → string
+ */
+export declare function defaultInterpolationSerializer(serializeAttrRef: (logicalName: string, attribute: string) => string, serializeRef: (refName: string) => string): InterpolationValueSerializer;
+/**
+ * Walk tagged template literal parts/values in lockstep,
+ * serializing each value via the provided serializer.
+ */
+export declare function buildInterpolatedString(templateParts: readonly string[], values: readonly unknown[], serializeValue: InterpolationValueSerializer): string;
+//# sourceMappingURL=intrinsic-interpolation.d.ts.map

package/dist/intrinsic-interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intrinsic-interpolation.d.ts","sourceRoot":"","sources":["../src/intrinsic-interpolation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,MAAM,4BAA4B,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;AAEtE;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,EACpE,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GACxC,4BAA4B,CA2C9B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,cAAc,EAAE,4BAA4B,GAC3C,MAAM,CASR"}

package/dist/intrinsic.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Marker symbol for Intrinsic type identification
+ */
+export declare const INTRINSIC_MARKER: unique symbol;
+/**
+ * Base interface for lexicon-provided intrinsic functions
+ */
+export interface Intrinsic {
+    readonly [INTRINSIC_MARKER]: true;
+    toJSON(): unknown;
+}
+/**
+ * Type guard to check if a value is an Intrinsic
+ */
+export declare function isIntrinsic(value: unknown): value is Intrinsic;
+/**
+ * Recursively unwrap intrinsic values by calling `toJSON()`.
+ *
+ * - If the value has the INTRINSIC_MARKER and a `toJSON` method, calls it.
+ * - If the value is an array, recurses into each element.
+ * - Otherwise returns the value as-is.
+ */
+export declare function resolveIntrinsicValue(value: unknown): unknown;
+//# sourceMappingURL=intrinsic.d.ts.map

package/dist/intrinsic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intrinsic.d.ts","sourceRoot":"","sources":["../src/intrinsic.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,gBAAgB,eAAgC,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC;IAClC,MAAM,IAAI,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAO9D;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAU7D"}

package/dist/lexicon-integrity.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Content hashing and integrity verification for lexicon artifacts.
+ */
+import type { BundleSpec } from "./lexicon.js";
+export interface ArtifactIntegrity {
+    algorithm: string;
+    artifacts: Record<string, string>;
+    composite: string;
+}
+/**
+ * Hash a single artifact's content using the runtime's hash algorithm.
+ */
+export declare function hashArtifact(content: string): string;
+/**
+ * Compute integrity for all artifacts in a BundleSpec.
+ */
+export declare function computeIntegrity(spec: BundleSpec): ArtifactIntegrity;
+/**
+ * Verify integrity of a BundleSpec against expected hashes.
+ */
+export declare function verifyIntegrity(spec: BundleSpec, expected: ArtifactIntegrity): {
+    ok: boolean;
+    mismatches: string[];
+};
+//# sourceMappingURL=lexicon-integrity.d.ts.map

package/dist/lexicon-integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-integrity.d.ts","sourceRoot":"","sources":["../src/lexicon-integrity.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,CAqBpE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,iBAAiB,GAC1B;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAkBvC"}

package/dist/lexicon-manifest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lexicon manifest validation and version compatibility checking.
+ */
+/**
+ * Check if the current version satisfies a semver range requirement.
+ * Supports: >=X.Y.Z, <=X.Y.Z, >X.Y.Z, <X.Y.Z, =X.Y.Z, X.Y.Z (exact match)
+ */
+export declare function checkVersionCompatibility(required: string, current: string): boolean;
+//# sourceMappingURL=lexicon-manifest.d.ts.map

package/dist/lexicon-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-manifest.d.ts","sourceRoot":"","sources":["../src/lexicon-manifest.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CA0CpF"}

package/dist/lexicon-output.d.ts

@@ -0,0 +1,66 @@
+import { INTRINSIC_MARKER, type Intrinsic } from "./intrinsic.js";
+import { AttrRef } from "./attrref.js";
+/**
+ * Represents a cross-lexicon output that bridges a producing lexicon (e.g. AWS)
+ * with any consuming lexicon (e.g. GitHub, Cloudflare).
+ *
+ * Implements Intrinsic so it can be used as Value<string> anywhere.
+ *
+ * Accepts either an AttrRef (resource attribute reference) or any Intrinsic
+ * (e.g. Sub, Join) for computed output values like constructed URLs.
+ */
+export declare class LexiconOutput implements Intrinsic {
+    readonly [INTRINSIC_MARKER]: true;
+    readonly sourceLexicon: string;
+    readonly sourceEntity: string;
+    readonly sourceAttribute: string | null;
+    readonly outputName: string;
+    /** @internal WeakRef to the source entity object for identity-based matching */
+    readonly _sourceParent: WeakRef<object> | null;
+    /** @internal Intrinsic value when constructed from an Intrinsic rather than AttrRef */
+    private readonly _intrinsic;
+    constructor(ref: AttrRef | Intrinsic | string, name: string);
+    /**
+     * Set the source entity logical name.
+     * Called during build when entity names are resolved.
+     * @internal
+     */
+    _setSourceEntity(name: string): void;
+    /**
+     * Returns the CloudFormation Output Value for this output.
+     * For AttrRef-based outputs: emits Fn::GetAtt.
+     * For Intrinsic-based outputs: delegates to the intrinsic's toJSON().
+     */
+    getOutputValue(): unknown;
+    /**
+     * Create a LexiconOutput with an auto-generated name from entity name and attribute.
+     * Used during cross-lexicon ref auto-detection.
+     *
+     * @param ref - The AttrRef pointing to the source entity
+     * @param entityName - The logical name of the source entity
+     * @returns A LexiconOutput with name `{entityName}_{attribute}`
+     */
+    static auto(ref: AttrRef, entityName: string): LexiconOutput;
+    toJSON(): {
+        "chant::output": string;
+    };
+}
+/**
+ * Create a LexiconOutput from an AttrRef or Intrinsic and a user-provided output name.
+ *
+ * Usage with AttrRef:
+ * ```ts
+ * const bucketArn = output(dataBucket.arn, "DataBucketArn");
+ * ```
+ *
+ * Usage with an intrinsic (e.g. a constructed URL):
+ * ```ts
+ * const solrUrl = output(Sub`http://${Ref(albDnsName)}/solr`, "solrUrl");
+ * ```
+ */
+export declare function output(ref: AttrRef | Intrinsic | string, name: string): LexiconOutput;
+/**
+ * Type guard to check if a value is a LexiconOutput
+ */
+export declare function isLexiconOutput(value: unknown): value is LexiconOutput;
+//# sourceMappingURL=lexicon-output.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-output.d.ts","sourceRoot":"","sources":["../src/lexicon-output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;GAQG;AACH,qBAAa,aAAc,YAAW,SAAS;IAC7C,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAG,IAAI,CAAU;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC/C,uFAAuF;IACvF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;gBAElC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM;IA8B3D;;;;OAIG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIpC;;;;OAIG;IACH,cAAc,IAAI,OAAO;IAOzB;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa;IAO5D,MAAM,IAAI;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;CAGtC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAErF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE"}

package/dist/lexicon-plugin-helpers.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared helpers for lexicon plugin implementations.
+ *
+ * Eliminates boilerplate across the 8 lexicon plugins by providing
+ * factory functions for common plugin methods: skills loading,
+ * MCP diff tool, and MCP catalog resource.
+ */
+import type { SkillDefinition } from "./lexicon.js";
+import type { McpToolContribution, McpResourceContribution } from "./mcp/types.js";
+import type { Serializer } from "./serializer.js";
+/**
+ * Metadata for a skill file on disk. Spread into the resulting SkillDefinition
+ * after the file content is read.
+ */
+export type SkillFileSpec = Omit<SkillDefinition, "content"> & {
+    /** Filename relative to the skills directory (e.g. "chant-aws.md") */
+    file: string;
+};
+/**
+ * Create a skills loader that reads .md files from a lexicon's skills directory.
+ *
+ * Usage in a plugin:
+ * ```ts
+ * import { createSkillsLoader } from "@intentius/chant/lexicon-plugin-helpers";
+ *
+ * const loadSkills = createSkillsLoader(import.meta.url, [
+ *   { file: "chant-aws.md", name: "chant-aws", description: "..." },
+ * ]);
+ *
+ * // In plugin:
+ * skills() { return loadSkills(); }
+ * ```
+ */
+export declare function createSkillsLoader(importMetaUrl: string, specs: SkillFileSpec[]): () => SkillDefinition[];
+/**
+ * Create an MCP diff tool contribution for a lexicon.
+ *
+ * All lexicons (except Azure) expose an identical-shape "diff" tool that
+ * compares current build output against previous output using the lexicon's
+ * serializer. The tool name is namespaced by `lexiconName` (e.g. `gcp:diff`)
+ * so multiple lexicons loaded together don't collide on the same tool key.
+ */
+export declare function createDiffTool(serializer: Serializer, description: string, lexiconName: string): McpToolContribution;
+/**
+ * Create an MCP resource that serves the lexicon's meta.json as a catalog.
+ *
+ * Most lexicons expose a "resource-catalog" resource with identical
+ * structure. The URI is namespaced by `lexiconName` (e.g.
+ * `gcp:resource-catalog`) so multiple lexicons loaded together don't
+ * collide on the same resource key.
+ *
+ * @param importMetaUrl — The plugin's import.meta.url (used to locate generated JSON)
+ * @param name — Display name (e.g. "AWS Resource Catalog")
+ * @param description — Resource description
+ * @param lexiconJsonFile — Filename of the generated lexicon JSON (e.g. "lexicon-aws.json")
+ * @param lexiconName — Short lexicon name (e.g. "aws", "gcp"). Becomes the URI prefix.
+ */
+export declare function createCatalogResource(importMetaUrl: string, name: string, description: string, lexiconJsonFile: string, lexiconName: string): McpResourceContribution;
+//# sourceMappingURL=lexicon-plugin-helpers.d.ts.map

package/dist/lexicon-plugin-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-plugin-helpers.d.ts","sourceRoot":"","sources":["../src/lexicon-plugin-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAI/C;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,GAAG;IAC7D,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,aAAa,EAAE,GACrB,MAAM,eAAe,EAAE,CAYzB;AAID;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,mBAAmB,CAsBrB;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,uBAAuB,CAmBzB"}

package/dist/lexicon-schema.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Zod schemas for lexicon manifest and registry validation.
+ */
+import { z } from "zod";
+import type { LexiconManifest } from "./lexicon.js";
+export declare const IntrinsicDefSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    outputKey: z.ZodOptional<z.ZodString>;
+    isTag: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const LexiconManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    chantVersion: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    intrinsics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        outputKey: z.ZodOptional<z.ZodString>;
+        isTag: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    pseudoParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const LexiconEntrySchema: z.ZodObject<{
+    resourceType: z.ZodString;
+    kind: z.ZodEnum<{
+        resource: "resource";
+        property: "property";
+    }>;
+    lexicon: z.ZodString;
+    attrs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            if_then: "if_then";
+            dependent_excluded: "dependent_excluded";
+            required_or: "required_or";
+            required_xor: "required_xor";
+        }>;
+        condition: z.ZodOptional<z.ZodUnknown>;
+        requirement: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    propertyConstraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        pattern: z.ZodOptional<z.ZodString>;
+        minLength: z.ZodOptional<z.ZodNumber>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        minimum: z.ZodOptional<z.ZodNumber>;
+        maximum: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodString>;
+        const: z.ZodOptional<z.ZodUnknown>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    createOnly: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    writeOnly: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    primaryIdentifier: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deprecatedProperties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    conditionalCreateOnly: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    replacementStrategy: z.ZodOptional<z.ZodEnum<{
+        delete_then_create: "delete_then_create";
+        create_then_delete: "create_then_delete";
+    }>>;
+    tagging: z.ZodOptional<z.ZodObject<{
+        taggable: z.ZodBoolean;
+        tagOnCreate: z.ZodBoolean;
+        tagUpdatable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    runtimeDeprecations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type LexiconEntryParsed = z.infer<typeof LexiconEntrySchema>;
+/**
+ * Validate a manifest from unknown input (object or JSON string).
+ * Throws a descriptive error on invalid input.
+ */
+export declare function validateManifest(data: unknown): LexiconManifest;
+/**
+ * Validate a registry JSON string into a typed record.
+ * Throws a descriptive error on invalid input.
+ */
+export declare function validateRegistry(json: string): Record<string, LexiconEntryParsed>;
+//# sourceMappingURL=lexicon-schema.d.ts.map

package/dist/lexicon-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-schema.d.ts","sourceRoot":"","sources":["../src/lexicon-schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,WAAW,CAAC;AAM/D,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAC;AAQH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;iBAOhC,CAAC;AAiCH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB7B,CAAC;AAMH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMpE;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CA2B/D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAmBjF"}