@intentius/chant-lexicon-fountain 0.33.0

package/dist/rules/ftn013-substitution-resolvable.ts

@@ -0,0 +1,93 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN013: `${VAR}` references in an Agent's config should resolve against
+ * its Environment's declared keys.
+ *
+ * Fountain validates substitution fail-complete at *spawn* time; this
+ * moves the same check to build time. Warning severity: a vault attached
+ * at conversation create can legitimately supply keys the environment
+ * does not declare (vault values win on collision), so an unresolved
+ * reference is suspicious, not certainly wrong.
+ */
+
+const VAR_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+
+function collectVars(node: unknown, acc: Set<string>): void {
+  if (typeof node === "string") {
+    for (const m of node.matchAll(VAR_RE)) acc.add(m[1]);
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) collectVars(item, acc);
+    return;
+  }
+  if (node && typeof node === "object") {
+    for (const v of Object.values(node)) collectVars(v, acc);
+  }
+}
+
+function declaredKeys(env: Record<string, unknown>): Set<string> {
+  const keys = new Set<string>();
+  const envVars = env.env_vars;
+  if (envVars && typeof envVars === "object") {
+    for (const k of Object.keys(envVars)) keys.add(k);
+  }
+  const secrets = env.secrets;
+  if (Array.isArray(secrets)) {
+    for (const s of secrets) {
+      const key = (s as { key?: unknown })?.key;
+      if (typeof key === "string") keys.add(key);
+    }
+  }
+  return keys;
+}
+
+export const substitutionResolvableCheck: PostSynthCheck = {
+  id: "FTN013",
+  description: "Agent ${VAR} references should resolve against the environment's declared keys",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+
+    for (const [name, entity] of ctx.entities) {
+      if (entity.entityType !== "Fountain::V1::Agent") continue;
+      const agent = propsOf(entity);
+
+      // Resolve the referenced environment entity when it is declared here.
+      const envRef = agent.environment;
+      let envEntity: Record<string, unknown> | undefined;
+      if (envRef && typeof envRef === "object") {
+        envEntity = propsOf(envRef);
+      } else if (typeof envRef === "string") {
+        const byName = ctx.entities.get(envRef);
+        if (byName?.entityType === "Fountain::V1::Environment") {
+          envEntity = propsOf(byName);
+        }
+      }
+      if (!envEntity) continue; // external environment — nothing to check against
+
+      const keys = declaredKeys(envEntity);
+      const used = new Set<string>();
+      collectVars(agent.mcp_servers, used);
+      collectVars(agent.system, used);
+
+      for (const v of used) {
+        if (!keys.has(v)) {
+          diagnostics.push({
+            checkId: "FTN013",
+            severity: "warning",
+            message:
+              `Agent "${name}" references \${${v}} but its environment declares no such ` +
+              `key — it will only resolve if a vault supplies it at conversation create`,
+            entity: name,
+            lexicon: "fountain",
+          });
+        }
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/dist/rules/ftn014-vault-shadowing.ts

@@ -0,0 +1,61 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN014: a Vault key that collides with a declared Environment key.
+ *
+ * Vault values win on key collision at spawn — silently. Shadowing a
+ * reviewed environment value is sometimes exactly the point (staging
+ * overrides) and sometimes an accident; either way it should be visible
+ * in review, so collisions warn.
+ */
+
+function keysOf(spec: Record<string, unknown>): Set<string> {
+  const keys = new Set<string>();
+  const envVars = spec.env_vars;
+  if (envVars && typeof envVars === "object") for (const k of Object.keys(envVars)) keys.add(k);
+  const secrets = spec.secrets;
+  if (Array.isArray(secrets)) {
+    for (const s of secrets) {
+      const key = (s as { key?: unknown })?.key;
+      if (typeof key === "string") keys.add(key);
+    }
+  }
+  return keys;
+}
+
+export const vaultShadowingCheck: PostSynthCheck = {
+  id: "FTN014",
+  description: "Vault keys shadowing a declared Environment key should be visible in review",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+    const environments: Array<[string, Set<string>]> = [];
+    const vaults: Array<[string, Set<string>]> = [];
+
+    for (const [name, entity] of ctx.entities) {
+      const spec = propsOf(entity);
+      if (entity.entityType === "Fountain::V1::Environment") environments.push([name, keysOf(spec)]);
+      if (entity.entityType === "Fountain::V1::Vault") vaults.push([name, keysOf(spec)]);
+    }
+
+    for (const [vaultName, vaultKeys] of vaults) {
+      for (const [envName, envKeys] of environments) {
+        const shadowed = [...vaultKeys].filter((k) => envKeys.has(k));
+        if (shadowed.length > 0) {
+          diagnostics.push({
+            checkId: "FTN014",
+            severity: "warning",
+            message:
+              `Vault "${vaultName}" shadows ${shadowed.map((k) => `"${k}"`).join(", ")} from ` +
+              `environment "${envName}" — vault values win silently on collision at spawn`,
+            entity: vaultName,
+            lexicon: "fountain",
+          });
+        }
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/dist/rules/ftn015-mcp-secret-env-substitution.ts

@@ -0,0 +1,49 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN015: secret-shaped MCP server env keys must use `${VAR}` references.
+ *
+ * A literal value under TOKEN/SECRET/KEY/PASSWORD-shaped keys in
+ * `mcp_servers.*.env` is a credential in source and in fountain's stored
+ * agent config. FTN001 catches known credential *shapes* at the AST;
+ * this catches the key-name signal regardless of value shape.
+ */
+
+const SECRET_KEY_RE = /(TOKEN|SECRET|PASSWORD|API_?KEY|CREDENTIAL)/i;
+const SUBSTITUTION_RE = /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/;
+
+export const mcpSecretEnvSubstitutionCheck: PostSynthCheck = {
+  id: "FTN015",
+  description: "Secret-shaped MCP env keys must be ${VAR} references, not literals",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+
+    for (const [name, entity] of ctx.entities) {
+      if (entity.entityType !== "Fountain::V1::Agent") continue;
+      const servers = propsOf(entity).mcp_servers as Record<string, unknown> | undefined;
+      if (!servers || typeof servers !== "object") continue;
+
+      for (const [serverName, server] of Object.entries(servers)) {
+        const env = (server as { env?: Record<string, unknown> })?.env;
+        if (!env || typeof env !== "object") continue;
+        for (const [key, value] of Object.entries(env)) {
+          if (!SECRET_KEY_RE.test(key)) continue;
+          if (typeof value === "string" && SUBSTITUTION_RE.test(value)) continue;
+          diagnostics.push({
+            checkId: "FTN015",
+            severity: "error",
+            message:
+              `Agent "${name}" mcp_servers.${serverName}.env.${key} looks secret-shaped ` +
+              `but is not a \${VAR} reference — literals here land in stored agent config`,
+            entity: name,
+            lexicon: "fountain",
+          });
+        }
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/dist/rules/ftn016-runtime-model-valid.ts

@@ -0,0 +1,50 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN016: runtime and model must be valid before apply.
+ *
+ * The generated types make these compile-time checks for typed authoring;
+ * this backstops untyped construction (imported templates, hand-built
+ * plans) so a typo fails the build instead of a 422 at apply.
+ */
+
+const RUNTIMES = new Set(["claude", "codex", "gemini", "opencode"]);
+const MODEL_RE = /^[a-z0-9_-]+\/[a-z0-9._-]+$/;
+
+export const runtimeModelValidCheck: PostSynthCheck = {
+  id: "FTN016",
+  description: "Agent runtime must be a known runtime and model canonical provider/model_id",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+
+    for (const [name, entity] of ctx.entities) {
+      if (entity.entityType !== "Fountain::V1::Agent") continue;
+      const agent = propsOf(entity) as { runtime?: unknown; model?: unknown };
+
+      if (typeof agent.runtime === "string" && !RUNTIMES.has(agent.runtime)) {
+        diagnostics.push({
+          checkId: "FTN016",
+          severity: "error",
+          message:
+            `Agent "${name}" runtime "${agent.runtime}" is not one of ` +
+            `${[...RUNTIMES].join(", ")}`,
+          entity: name,
+          lexicon: "fountain",
+        });
+      }
+      if (typeof agent.model === "string" && !MODEL_RE.test(agent.model)) {
+        diagnostics.push({
+          checkId: "FTN016",
+          severity: "error",
+          message: `Agent "${name}" model "${agent.model}" is not canonical provider/model_id form`,
+          entity: name,
+          lexicon: "fountain",
+        });
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/dist/rules/ftn017-unique-resource-names.ts

@@ -0,0 +1,43 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN017: resource names must be unique per kind.
+ *
+ * fountainApply reconciles by name; two entities of the same kind
+ * resolving to the same fountain name would fight over one live
+ * resource — the second apply step silently becomes an update of the
+ * first one's creation.
+ */
+export const uniqueResourceNamesCheck: PostSynthCheck = {
+  id: "FTN017",
+  description: "Two declarations of the same kind must not resolve to the same fountain name",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+    const seen = new Map<string, string>();
+
+    for (const [entityName, entity] of ctx.entities) {
+      if (!entity.entityType.startsWith("Fountain::V1::")) continue;
+      const props = propsOf(entity);
+      const resourceName = typeof props.name === "string" ? props.name : entityName;
+      const key = `${entity.entityType}/${resourceName}`;
+      const first = seen.get(key);
+      if (first) {
+        diagnostics.push({
+          checkId: "FTN017",
+          severity: "error",
+          message:
+            `"${entityName}" and "${first}" both resolve to ${key} — apply would ` +
+            `reconcile them onto one live resource`,
+          entity: entityName,
+          lexicon: "fountain",
+        });
+      } else {
+        seen.set(key, entityName);
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/dist/serializer.d.ts

@@ -0,0 +1,3 @@
+import type { Serializer } from "@intentius/chant";
+export declare const fountainSerializer: Serializer;
+//# 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,EAAgC,MAAM,kBAAkB,CAAC;AAsBjF,eAAO,MAAM,kBAAkB,EAAE,UAwDhC,CAAC"}

package/dist/skills/chant-fountain-locked-sandboxes.md

@@ -0,0 +1,34 @@
+---
+skill: chant-fountain-locked-sandboxes
+description: Declare locked-down fountain environments for untrusted or security-sensitive agents, and run conversations against them
+user-invocable: true
+---
+
+# Locked-Down Sandboxes and Conversation Runs
+
+## The posture
+
+For an agent handling anything sensitive (a repo checkout, an internal API), declare the environment closed by construction:
+
+```ts
+export const lockedEnv = new Environment({
+  name: "concierge-env",
+  networking_type: "limited",
+  networking_config: { allowed_hosts: ["registry.npmjs.org", "github.com"] },
+  metadata: { "managed-by": "chant" },
+});
+```
+
+Semantics (from fountain's own schema): `unrestricted` is a no-op — sprites are open by default. `limited` restricts egress to `allowed_hosts`; with **no** hosts (or an empty list) it denies all egress — deny-all, not allow-all. So `limited` + `[]` is the isolation mode.
+
+Pair it with a closed vault policy on the agent — `allowed_vault_ids: []` — so no conversation can override the reviewed environment at spawn, and give the sandbox **no cloud credentials of any kind**: anything readable inside is exfiltratable by prompt injection. Services the agent needs live outside the sandbox behind their own auth; the sandbox gets at most a conversation-scoped token.
+
+Lint posture: FTN010/FTN011 fire on missing/unrestricted networking at warning severity by default. For repos whose environments are all concierge-class, promote them to error via project rules.
+
+## Drift is the alarm
+
+The environment's config is the enforcement boundary, so watch it: `chant lifecycle diff --live` flags a UI edit that adds a secret, opens networking, or drops the marker. Wire it into a scheduled watch — an out-of-band change to a locked environment is an incident, not housekeeping.
+
+## Running conversations
+
+Conversations are runs, not resources. Use the `fountainRun` activity: resolves the agent by name, starts (optionally with a prompt and an allowlisted vault), polls to `completed | failed | timed_out`, and terminates at its deadline so a hung sandbox never outlives the op. Multi-turn interaction (follow-up prompts, interrupt) is fountain's own conversations API — keep chant to the lifecycle edges.

package/dist/skills/chant-fountain-secrets.md

@@ -0,0 +1,29 @@
+---
+skill: chant-fountain-secrets
+description: Handle fountain secrets, env vars, and ${VAR} substitution safely from chant
+user-invocable: true
+---
+
+# Fountain Secrets and Substitution
+
+## The model
+
+Everything materialized into a fountain sandbox must be presumed exfiltrated once untrusted agent code runs. Order of preference:
+
+1. **`${VAR}` substitution references** in agent config (MCP server env, system prompts). Resolved at spawn from the merged environment + vault sets. Never a value in source.
+2. **Environment secrets** (`spec.secrets`) — encrypted at rest, write-only over the API (values are never returned once stored). `fountainApply` upserts them through the sub-resource; a changed value cannot be detected, only overwritten.
+3. **`env_vars`** — plaintext config only. FTN012 errors on credential-shaped keys or values here.
+
+Never put a literal credential anywhere in a declaration: FTN001 catches known shapes (AWS keys, GitHub/Slack tokens, `sk-`/`ftn_` keys, private key material) at the AST; FTN015 errors on secret-shaped MCP env keys that are not `${VAR}` references.
+
+## Vault semantics
+
+Vault values **win on key collision** with the environment, silently, at spawn. FTN014 warns when a declared vault shadows a declared environment key, so the override is visible in review. Which vaults may attach to an agent is scoped by `allowed_vault_ids` (nullable: `null` = any tenant vault, `[]` = none, list = allowlist) — set `[]` on agents whose environment must not be overridable.
+
+## Build-time resolution check
+
+FTN013 warns when an agent references `${VAR}` and its declared environment has no such key (env_vars or secret keys). A vault can legitimately supply it at conversation create — the warning is "confirm this is intentional," not "this is broken."
+
+## Round-trips and their limits
+
+`chant import --from` exports live resources but never secrets: values are write-only upstream, and secret keys are not on the typed request surface. Re-declare imported environments' secrets through your secret provider. Upstream discussion of a reference-based model that would fix this: BinaryBourbon/fountain#148.

package/dist/skills/chant-fountain.md

@@ -0,0 +1,45 @@
+---
+skill: chant-fountain
+description: Declare, lint, and reconcile fountain Environments, Vaults, and Agents from a chant project
+user-invocable: true
+---
+
+# Fountain Workloads as Typed Estate
+
+## What this lexicon covers
+
+[fountain](https://github.com/BinaryBourbon/fountain) runs coding agents in sandboxed VMs. Its workload layer is three kinds — `Environment` (sandbox baseline), `Vault` (env-var overrides), `Agent` (a runnable agent config) — and this lexicon declares them as typed chant resources. Conversations are runs, not resources: start them with the `fountainRun` op, never declare them.
+
+The source of truth is the TypeScript in `src/`. `chant build` serializes it to fountain's own manifest YAML (ejectable — `fountain apply -f` accepts it verbatim) plus a `fountain-plan.json` sidecar that `fountainApply` reconciles against the API directly: create-if-new, update-by-name, opt-in owned-only prune keyed on the `managed-by: chant` metadata marker.
+
+## Authoring
+
+```ts
+import { Environment, Agent } from "@intentius/chant-lexicon-fountain";
+
+export const env = new Environment({
+  name: "team-env",
+  networking_type: "limited",                     // FTN010 requires explicit intent
+  networking_config: { allowed_hosts: ["github.com"] },
+  metadata: { "managed-by": "chant" },            // enables owned-only reconcile/prune
+});
+
+export const helper = new Agent({
+  name: "helper",
+  model: "anthropic/claude-sonnet-4-6",
+  runtime: "claude",
+  environment: env,                               // typed ref — dangling name = build error
+  skills: [{ source: "owner/skills-repo", ref: "v1.0.0" }],  // always pin a ref
+});
+```
+
+## Endpoint and auth
+
+`FOUNTAIN_ENDPOINT` (defaults to the hosted instance) + `FOUNTAIN_TOKEN` (mint via `POST /api/auth/token` with email+password, or the account UI). The same code applies to a local `mix phx.server` fountain by pointing `FOUNTAIN_ENDPOINT` at it — registration and token mint work headless, so CI needs no browser.
+
+## The loop
+
+1. `chant build` — synthesize + lint (FTN rules catch open networking, credential literals, unresolvable `${VAR}` refs before review).
+2. `chant run <apply op>` or call `fountainApply` — reconcile. Idempotent by name.
+3. `chant lifecycle diff --live` — drift: a UI edit to an owned Environment shows up here.
+4. `chant import --from` — adopt UI-built resources into typed files (secrets stay behind; see the secrets skill).

package/dist/spec/fetch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Fetch the fountain OpenAPI spec.
+ *
+ * Fountain serves its OpenAPI 3.1 spec from the running app at
+ * /api/openapi.json (generated from code via OpenApiSpex; public, no auth).
+ * This is an unversioned live endpoint: it always serves the spec of
+ * whatever is currently deployed, with no release tag to pin — fountain
+ * follows the rolling-spec model (like fly). A versioned spec artifact per
+ * release shipped upstream as a release asset (BinaryBourbon/fountain#140);
+ * when the hosted endpoint is reliably current this fetcher can prefer it.
+ *
+ * Fallback: a committed snapshot (fountain-openapi.snapshot.json) keeps
+ * generation hermetic when the live endpoint is unreachable — CI runs,
+ * offline dev, or the current state where the hosted instance predates the
+ * endpoint. The snapshot is refreshed alongside surface.snapshot.json when
+ * upstream moves (regenerate from a fountain checkout via
+ * `mix openapi.spec.json --spec FountainWeb.ApiSpec`).
+ */
+/**
+ * Fetch the fountain OpenAPI spec with caching, falling back to the
+ * committed snapshot when the live endpoint is unreachable. Returns a
+ * single-entry map — the whole spec is one document; the parser fans it
+ * out into per-kind results.
+ */
+export declare function fetchSchemas(options?: {
+    force?: boolean;
+}): Promise<Map<string, Buffer>>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/spec/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/spec/fetch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAcH;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAe9F"}

package/dist/spec/parse.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Fountain OpenAPI parser.
+ *
+ * Fountain's spec (OpenApiSpex, served at /api/openapi.json) is
+ * request/response DTOs, so we generate a curated set of resources — the
+ * three kinds `fountain apply` reconciles: Environment, Vault, Agent.
+ * Each pairs a request schema (writable authoring surface) with a response
+ * schema (read-only attributes). Object schemas reachable from the request
+ * schemas (e.g. Repository) are emitted as standalone property-type classes.
+ *
+ * Conversations are deliberately not a resource: they are runs with a
+ * status lifecycle, modeled as ops, not declarables.
+ */
+import { type PropertyConstraints } from "@intentius/chant/codegen/json-schema";
+export type { PropertyConstraints };
+export interface ParsedProperty {
+    name: string;
+    tsType: string;
+    required: boolean;
+    description?: string;
+    constraints: PropertyConstraints;
+}
+export interface ParsedResource {
+    typeName: string;
+    description?: string;
+    properties: ParsedProperty[];
+    attributes: Array<{
+        name: string;
+        tsType: string;
+    }>;
+}
+export interface FountainParseResult {
+    resource: ParsedResource;
+    /** Always empty — fountain emits property types as standalone results. */
+    propertyTypes: Array<{
+        name: string;
+        defType: string;
+    }>;
+    /** Always empty — enums are inlined as string-literal unions. */
+    enums: Array<{
+        name: string;
+        values: string[];
+    }>;
+    /** Whether this entity is a property type (nested config shape). */
+    isProperty?: boolean;
+}
+/**
+ * Parse the fountain OpenAPI spec into the curated resources and the
+ * property types reachable from their request schemas.
+ */
+export declare function parseFountainOpenAPI(data: string | Buffer): FountainParseResult[];
+/** Convert a schema name into a PascalCase class-name segment. */
+export declare function schemaToClassName(schemaName: string): string;
+/** Extract short name: "Fountain::V1::Agent" → "Agent". */
+export declare function fountainShortName(typeName: string): string;
+/** Extract service name: "Fountain::V1::Agent" → "V1". */
+export declare function fountainServiceName(typeName: string): string;
+//# sourceMappingURL=parse.d.ts.map

package/dist/spec/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/spec/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAKL,KAAK,mBAAmB,EACzB,MAAM,sCAAsC,CAAC;AAI9C,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,mBAAmB,CAAC;CAClC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,UAAU,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,0EAA0E;IAC1E,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxD,iEAAiE;IACjE,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACjD,oEAAoE;IACpE,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAqCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,mBAAmB,EAAE,CAwEjF;AAmID,kEAAkE;AAClE,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,2DAA2D;AAC3D,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED,0DAA0D;AAC1D,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG5D"}

package/dist/types/index.d.ts

@@ -0,0 +1,60 @@
+// Code generated by chant fly generate. DO NOT EDIT.
+
+// --- Fly Resource classes ---
+
+export declare class Agent {
+  constructor(props: {
+    model: string;
+    name: string;
+    runtime: "claude" | "codex" | "gemini" | "opencode";
+    /** Vaults a conversation may attach to this agent. null (default) allows any vault the tenant owns; an empty list forbids attaching any vault; a non-empty list is an allowlist. */
+    allowed_vault_ids?: string[];
+    description?: string;
+    environment_id?: string;
+    mcp_servers?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    /** Each entry is either inline (`{name, content}` — full SKILL.md text written to the sprite) or github (`{source, ref?, name?}` — installed on the sprite via the skills.sh CLI, optionally pinned to a tag/branch/sha via `ref`). Exactly one of `content` or `source` must be set on each entry. */
+    skills?: Record<string, unknown>[];
+    system?: string;
+  });
+  readonly id: string;
+  readonly inserted_at: string;
+  readonly updated_at: string;
+}
+
+export declare class Environment {
+  constructor(props: {
+    name: string;
+    env_vars?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    /** Refines networking_type: limited. allowed_hosts is the only key honored today; unknown keys are ignored. Under limited, egress is restricted to the allowlisted domains. With no allowed_hosts (or an empty list), the sandbox denies all egress by default — this is a deny-all, not an allow-all. */
+    networking_config?: Record<string, unknown>;
+    networking_type?: "limited" | "unrestricted";
+    packages?: Record<string, unknown>;
+    repositories?: Repository[];
+    setup_script?: string;
+  });
+  readonly id: string;
+  readonly inserted_at: string;
+  readonly updated_at: string;
+}
+
+export declare class Vault {
+  constructor(props: {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+  });
+  readonly id: string;
+  readonly inserted_at: string;
+  readonly updated_at: string;
+}
+
+// --- Property type classes ---
+
+export declare class Repository {
+  constructor(props: {
+    mount_path: string;
+    url: string;
+  });
+}

package/dist/validate-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+export {};
+//# sourceMappingURL=validate-cli.d.ts.map

package/dist/validate-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-cli.d.ts","sourceRoot":"","sources":["../src/validate-cli.ts"],"names":[],"mappings":""}

package/dist/validate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Validate generated lexicon-fountain artifacts.
+ *
+ * Thin wrapper around the core validation framework
+ * with fountain-specific configuration.
+ */
+import { type ValidateResult } from "@intentius/chant/codegen/validate";
+export type { ValidateCheck, ValidateResult } from "@intentius/chant/codegen/validate";
+/**
+ * Validate the generated lexicon-fountain artifacts.
+ */
+export declare function validate(opts?: {
+    basePath?: string;
+}): Promise<ValidateResult>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAElG,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAWvF;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAQpF"}