@intentius/chant-lexicon-fly 0.16.0 → 0.17.0

package/README.md

@@ -26,9 +26,9 @@ It fits two kinds of user: teams running on Fly who want their infrastructure as
 ## Author infrastructure as typed code
 
 ```ts
-import { App, Machine, MachineConfig, MachineGuest } from "@intentius/chant-lexicon-fly";
+import { App, Machine, MachineConfig, MachineGuest, Fly } from "@intentius/chant-lexicon-fly";
 
-export const app = new App({ name: "my-app" });
+export const app = new App({ name: "my-app", org_slug: Fly.OrgSlug });
 
 export const web = new Machine({
   region: "iad",

package/dist/coverage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Coverage analysis for the fly lexicon (#804) — how much of the generated
+ * Machines API surface the lexicon's typed resources cover. Thin wrapper over
+ * the shared `computeCoverage`, mirroring the docker/gcp/github peers.
+ */
+import { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds, type CoverageReport, type CoverageThresholds } from "@intentius/chant/codegen/coverage";
+export type { CoverageReport, CoverageThresholds };
+export { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds };
+/** Run coverage analysis for the fly lexicon. */
+export declare function analyzeFlyCoverage(opts?: {
+    basePath?: string;
+    verbose?: boolean;
+    minOverall?: number;
+}): Promise<CoverageReport>;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EACL,eAAe,EACf,UAAU,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC;AAEtF,iDAAiD;AACjD,wBAAsB,kBAAkB,CAAC,IAAI,CAAC,EAAE;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,cAAc,CAAC,CAqB1B"}

package/dist/mcp/context-tools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Read-only MCP tools that expose what `chant build` already computes about a
+ * Fly deploy — its apps and machines, the flaps create bodies, image pinning,
+ * and the lexicon's findings — so an agent can ask about a change *before it
+ * runs* (#804).
+ *
+ * Every tool builds from source and returns data. None touch a live Fly org,
+ * read run history, or write anything — the same context-producer boundary the
+ * AWS/GitLab context tools hold.
+ */
+import type { McpToolContribution } from "@intentius/chant/mcp/types";
+/** A container image reference is pinned when it names a digest, not a tag. */
+export declare function imagePinned(image: string): boolean;
+export declare function flyContextTools(): McpToolContribution[];
+//# sourceMappingURL=context-tools.d.ts.map

package/dist/mcp/context-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-tools.d.ts","sourceRoot":"","sources":["../../src/mcp/context-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AA+BtE,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,eAAe,IAAI,mBAAmB,EAAE,CAoEvD"}

package/dist/op/activities/flaps.d.ts

@@ -3,7 +3,7 @@ export interface FlapsUpArgs {
     name?: string;
     /** Host port mapped to the emulator's `:4280`. Default: `4280`. */
     port?: number;
-    /** Image. Default: `ghcr.io/intentius/mudflaps:0.3.0`. */
+    /** Image. Default: `ghcr.io/intentius/mudflaps:0.3.1`. */
     image?: string;
     /** Readiness timeout in ms. Default: `60000`. */
     timeoutMs?: number;

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAkD,MAAM,0BAA0B,CAAC;AAiB9G;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,aAsQvB,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAkD,MAAM,0BAA0B,CAAC;AAmB9G;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,aA8QvB,CAAC"}

package/dist/reference-catalog.d.ts

@@ -0,0 +1,21 @@
+import type { ReferenceCatalog } from "@intentius/chant/lexicon";
+/**
+ * Fly reference catalog (#804) — how observed Fly resources reference each other,
+ * so `chant graph --live` reconstructs the topology and draws the App as a
+ * boundary box (the reference resolver, chant#778; containment, chant#779).
+ *
+ * Fly's relationships are app-centric and simple. `describeResources`
+ * (./describe-resources.ts) already returns the rich per-resource shape — each
+ * app-scoped resource carries its owning `app`, and a machine carries its full
+ * `config` (with `mounts`) — so, unlike AWS (chant#784), Fly needs **no**
+ * `enrichLiveAttrs`: the references are already in the observed attributes.
+ *
+ * Keyed to the `describeResources` attribute shape:
+ *   - App        → `{ app }`           (physicalId = app name)
+ *   - Machine    → `{ app, config }`   (config.mounts[].volume references a Volume)
+ *   - Volume     → `{ app, volumeName }`
+ *   - IPAddress  → `{ app, ... }`
+ *   - Certificate→ `{ app, ... }`
+ */
+export declare const flyReferenceCatalog: ReferenceCatalog;
+//# sourceMappingURL=reference-catalog.d.ts.map

package/dist/reference-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-catalog.d.ts","sourceRoot":"","sources":["../src/reference-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAkBjC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-fly",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "type": "module",
   "files": [
     "src/",
@@ -53,7 +53,7 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.16.0"
+    "@intentius/chant": "^0.17.0"
   },
   "description": "Google Cloud lexicon for chant — declarative IaC in TypeScript",
   "license": "Apache-2.0",

package/src/coverage.ts

@@ -0,0 +1,49 @@
+/**
+ * Coverage analysis for the fly lexicon (#804) — how much of the generated
+ * Machines API surface the lexicon's typed resources cover. Thin wrapper over
+ * the shared `computeCoverage`, mirroring the docker/gcp/github peers.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  computeCoverage,
+  overallPct,
+  formatSummary,
+  formatVerbose,
+  checkThresholds,
+  type CoverageReport,
+  type CoverageThresholds,
+} from "@intentius/chant/codegen/coverage";
+
+export type { CoverageReport, CoverageThresholds };
+export { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds };
+
+/** Run coverage analysis for the fly lexicon. */
+export async function analyzeFlyCoverage(opts?: {
+  basePath?: string;
+  verbose?: boolean;
+  minOverall?: number;
+}): Promise<CoverageReport> {
+  const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
+  const lexiconPath = join(basePath, "src", "generated", "lexicon-fly.json");
+
+  if (!existsSync(lexiconPath)) {
+    throw new Error(`Generated lexicon not found at ${lexiconPath}. Run "chant dev generate" first.`);
+  }
+
+  const report = computeCoverage(readFileSync(lexiconPath, "utf-8"));
+
+  console.error(opts?.verbose ? formatVerbose(report) : formatSummary(report));
+
+  if (typeof opts?.minOverall === "number") {
+    const result = checkThresholds(report, { minOverallPct: opts.minOverall });
+    if (!result.ok) {
+      for (const v of result.violations) console.error(`  FAIL: ${v}`);
+      throw new Error("Coverage below threshold");
+    }
+  }
+
+  return report;
+}

package/src/mcp/context-tools.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest";
+import { flyContextTools, imagePinned } from "./context-tools";
+
+describe("flyContextTools", () => {
+  const tools = flyContextTools();
+
+  it("exposes the read-only fly:* context tools", () => {
+    expect(tools.map((t) => t.name).sort()).toEqual(["fly:app", "fly:checks", "fly:plan", "fly:references"]);
+  });
+
+  it("every tool has a description, a path input, and a handler", () => {
+    for (const t of tools) {
+      expect(t.description.length).toBeGreaterThan(10);
+      expect(t.inputSchema.type).toBe("object");
+      expect(t.inputSchema.properties).toHaveProperty("path");
+      expect(typeof t.handler).toBe("function");
+    }
+  });
+});
+
+describe("imagePinned", () => {
+  it("is pinned only when the image names a digest", () => {
+    expect(imagePinned("flyio/hellofly@sha256:abc123")).toBe(true);
+    expect(imagePinned("flyio/hellofly:latest")).toBe(false);
+    expect(imagePinned("flyio/hellofly")).toBe(false);
+  });
+});

package/src/mcp/context-tools.ts

@@ -0,0 +1,120 @@
+/**
+ * Read-only MCP tools that expose what `chant build` already computes about a
+ * Fly deploy — its apps and machines, the flaps create bodies, image pinning,
+ * and the lexicon's findings — so an agent can ask about a change *before it
+ * runs* (#804).
+ *
+ * Every tool builds from source and returns data. None touch a live Fly org,
+ * read run history, or write anything — the same context-producer boundary the
+ * AWS/GitLab context tools hold.
+ */
+
+import { build, type BuildResult } from "@intentius/chant/build";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { runPostSynthChecks, getPrimaryOutput } from "@intentius/chant/lint/post-synth";
+import { postSynthChecks } from "../lint/post-synth";
+import type { McpToolContribution } from "@intentius/chant/mcp/types";
+import { flySerializer } from "../serializer";
+import { parsePlan, isAppRequest, isMachineRequest, type FlyPlan, type FlapsRequest } from "../op/activities/fly-apply";
+
+const PATH_INPUT = {
+  type: "object" as const,
+  properties: {
+    path: { type: "string", description: "Path to the chant project directory (default: current directory)" },
+  },
+};
+
+/** Build the project and parse the flaps plan the serializer emits. */
+async function buildFly(path: string): Promise<{ plan: FlyPlan; result: BuildResult; output?: string | SerializerResult }> {
+  const result = await build(path || ".", [flySerializer]);
+  const output = result.outputs.get("fly");
+  let plan: FlyPlan = {};
+  if (output) {
+    try {
+      plan = parsePlan(getPrimaryOutput(output));
+    } catch {
+      // not a parseable fly plan — leave empty
+    }
+  }
+  return { plan, result, output };
+}
+
+const machineImage = (req: FlapsRequest): string | undefined => {
+  const config = req.body.config as { image?: unknown } | undefined;
+  return typeof config?.image === "string" ? config.image : undefined;
+};
+
+/** A container image reference is pinned when it names a digest, not a tag. */
+export function imagePinned(image: string): boolean {
+  return image.includes("@sha256:");
+}
+
+export function flyContextTools(): McpToolContribution[] {
+  return [
+    {
+      name: "fly:app",
+      description:
+        "Build the project and summarize the declared Fly apps and machines — regions, images, guest sizing — from source. Read-only; never touches a live Fly org.",
+      inputSchema: PATH_INPUT,
+      async handler(params: Record<string, unknown>): Promise<unknown> {
+        const { plan } = await buildFly(String(params.path ?? "."));
+        const apps: Array<{ name: string; org_slug: unknown }> = [];
+        const machines: Array<{ name: string; region: unknown; image: string | null; guest: unknown }> = [];
+        for (const [name, req] of Object.entries(plan)) {
+          if (isAppRequest(req)) {
+            apps.push({ name: String(req.body.app_name ?? name), org_slug: req.body.org_slug ?? null });
+          } else if (isMachineRequest(req)) {
+            machines.push({
+              name: String(req.body.name ?? name),
+              region: req.body.region ?? null,
+              image: machineImage(req) ?? null,
+              guest: (req.body.config as { guest?: unknown } | undefined)?.guest ?? null,
+            });
+          }
+        }
+        return { apps, machines };
+      },
+    },
+    {
+      name: "fly:checks",
+      description:
+        "Build the project and return the fly lexicon's post-synth findings (machine requires an image, a mount references a declared Volume) as JSON. Read-only.",
+      inputSchema: PATH_INPUT,
+      async handler(params: Record<string, unknown>): Promise<unknown> {
+        const { output, result } = await buildFly(String(params.path ?? "."));
+        if (!output) return { findings: [], note: "no Fly plan produced from this project" };
+        const scoped: BuildResult = { ...result, outputs: new Map([["fly", output]]) };
+        const diags = runPostSynthChecks(postSynthChecks, scoped);
+        return {
+          findings: diags.map((d) => ({ id: d.checkId, severity: d.severity, entity: d.entity ?? null, message: d.message })),
+        };
+      },
+    },
+    {
+      name: "fly:references",
+      description:
+        "Build the project and list each machine's container image and whether it is pinned to a digest (vs a floating tag). Read-only.",
+      inputSchema: PATH_INPUT,
+      async handler(params: Record<string, unknown>): Promise<unknown> {
+        const { plan } = await buildFly(String(params.path ?? "."));
+        const images: Array<{ machine: string; image: string; pinned: boolean }> = [];
+        for (const [name, req] of Object.entries(plan)) {
+          if (!isMachineRequest(req)) continue;
+          const image = machineImage(req);
+          if (image) images.push({ machine: String(req.body.name ?? name), image, pinned: imagePinned(image) });
+        }
+        return images;
+      },
+    },
+    {
+      name: "fly:plan",
+      description:
+        "Build the project and return the flaps create bodies the serializer emits — exactly what flyApply would POST to the Machines API. Read-only.",
+      inputSchema: PATH_INPUT,
+      async handler(params: Record<string, unknown>): Promise<unknown> {
+        const { plan } = await buildFly(String(params.path ?? "."));
+        return plan;
+      },
+    },
+  ];
+}

package/src/op/activities/flaps.test.ts

@@ -10,7 +10,7 @@ import {
 describe("flaps (mudflaps) lifecycle commands", () => {
   test("run command uses defaults and maps the port", () => {
     expect(flapsRunCommand({})).toBe(
-      "docker run -d --rm --name chant-mudflaps -p 4280:4280 ghcr.io/intentius/mudflaps:0.3.0",
+      "docker run -d --rm --name chant-mudflaps -p 4280:4280 ghcr.io/intentius/mudflaps:0.3.1",
     );
   });
 

package/src/op/activities/flaps.ts

@@ -5,7 +5,7 @@ export interface FlapsUpArgs {
   name?: string;
   /** Host port mapped to the emulator's `:4280`. Default: `4280`. */
   port?: number;
-  /** Image. Default: `ghcr.io/intentius/mudflaps:0.3.0`. */
+  /** Image. Default: `ghcr.io/intentius/mudflaps:0.3.1`. */
   image?: string;
   /** Readiness timeout in ms. Default: `60000`. */
   timeoutMs?: number;
@@ -23,7 +23,7 @@ export interface FlapsDownArgs {
 // with FLY_FLAPS_BASE_URL. Shared lifecycle: emulatorLifecycle (#746).
 const flaps = emulatorLifecycle({
   name: "chant-mudflaps",
-  image: "ghcr.io/intentius/mudflaps:0.3.0",
+  image: "ghcr.io/intentius/mudflaps:0.3.1",
   containerPort: 4280,
   healthPath: "/_mudflaps/health",
 });

package/src/plugin.ts

@@ -14,6 +14,8 @@ import { hover } from "./lsp/hover";
 import { detectTemplate as detectFlyTemplate } from "./detect";
 import { FlyParser } from "./import/parser";
 import { FlyGenerator } from "./import/generator";
+import { flyReferenceCatalog } from "./reference-catalog";
+import { flyContextTools } from "./mcp/context-tools";
 
 /**
  * fly lexicon plugin.
@@ -39,8 +41,8 @@ export const flyPlugin: LexiconPlugin = {
   },
 
   async coverage(options?: { verbose?: boolean; minOverall?: number }): Promise<void> {
-    // TODO: Implement coverage analysis
-    console.error("Coverage analysis not yet implemented");
+    const { analyzeFlyCoverage } = await import("./coverage");
+    await analyzeFlyCoverage({ verbose: options?.verbose, minOverall: options?.minOverall });
   },
 
   async package(options?: { verbose?: boolean; force?: boolean }): Promise<void> {
@@ -86,7 +88,7 @@ export const flyPlugin: LexiconPlugin = {
       examples: [
         {
           title: "Author an App and a Machine",
-          output: "new App({ name: \"my-app\" });\nnew Machine({ region: \"iad\", config: new MachineConfig({ image: \"flyio/hellofly:latest\" }) })",
+          output: "new App({ name: \"my-app\", org_slug: Fly.OrgSlug });\nnew Machine({ region: \"iad\", config: new MachineConfig({ image: \"flyio/hellofly:latest\" }) })",
         },
         {
           title: "Deploy against mudflaps offline",
@@ -134,11 +136,14 @@ export const flyPlugin: LexiconPlugin = {
   ]),
 
   mcpTools() {
-    return []; // TODO: Implement MCP tools
+    return flyContextTools();
   },
 
   mcpResources() {
-    return []; // TODO: Implement MCP resources
+    // No standing MCP resources: Fly's read-only context is the fly:* tools above
+    // (build-from-source) plus the chant-fly skills. There's no static catalog or
+    // per-project artifact to expose as a resource.
+    return [];
   },
 
   detectTemplate(data: unknown) {
@@ -282,4 +287,9 @@ export { app, web };
     const { exportResources } = await import("./export-resources");
     return exportResources(options);
   },
+
+  // Live graph edges (#804): how observed Fly resources reference each other, so
+  // `chant graph --live` reconstructs the topology (App boundary + mount edges).
+  // No `enrichLiveAttrs` needed — describeResources already returns rich attrs.
+  referenceCatalog: flyReferenceCatalog,
 };

package/src/reference-catalog.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from "vitest";
+import { reconstructEdges, containmentGroups } from "@intentius/chant/graph-refs";
+import type { IRNode } from "@intentius/chant/graph-ir";
+import { flyReferenceCatalog } from "./reference-catalog";
+
+const n = (id: string, kind: string, physicalId: string, attrs: Record<string, unknown>): IRNode => ({
+  id,
+  kind,
+  lexicon: "fly",
+  physicalId,
+  attrs,
+});
+
+// The shape describeResources() returns: an App boundary, machines (one mounting
+// a volume), a volume, an IP — all app-scoped.
+const nodes: IRNode[] = [
+  n("app", "Fly::Machines::App", "my-app", { app: "my-app" }),
+  n("web", "Fly::Machines::Machine", "m1", { app: "my-app", machineName: "web", config: { image: "flyio/hellofly:latest", mounts: [{ volume: "vol_1", path: "/data" }] } }),
+  n("worker", "Fly::Machines::Machine", "m2", { app: "my-app", machineName: "worker", config: { image: "flyio/hellofly:latest" } }),
+  n("data", "Fly::Machines::Volume", "vol_1", { app: "my-app", volumeName: "data" }),
+  n("ip", "Fly::Machines::IPAddress", "1.2.3.4", { app: "my-app", family: "v4" }),
+];
+
+describe("flyReferenceCatalog — live graph edges", () => {
+  const { edges, containment, dangling } = reconstructEdges(nodes, flyReferenceCatalog);
+
+  it("contains every app-scoped resource in its App (boundary box)", () => {
+    for (const child of ["web", "worker", "data", "ip"]) {
+      expect(containment).toContainEqual({ child, parent: "app", label: "in app" });
+    }
+    // containment is never an edge
+    expect(edges.some((e) => e.to === "app")).toBe(false);
+  });
+
+  it("reconstructs the machine → volume mount edge", () => {
+    // mount.volume "vol_1" matches the Volume's physicalId
+    expect(edges).toContainEqual({ from: "web", to: "data", kind: "ref", viaAttr: "mounts" });
+    // the machine with no mounts has no volume edge
+    expect(edges.some((e) => e.from === "worker" && e.to === "data")).toBe(false);
+  });
+
+  it("has no dangling references", () => {
+    expect(dangling).toEqual([]);
+  });
+
+  it("containment groups nest App → resources (for #779 boundaries)", () => {
+    const g = containmentGroups(containment);
+    expect(g.app).toEqual(expect.arrayContaining(["web", "worker", "data", "ip"]));
+  });
+});

package/src/reference-catalog.ts

@@ -0,0 +1,39 @@
+import type { ReferenceCatalog } from "@intentius/chant/lexicon";
+
+/**
+ * Fly reference catalog (#804) — how observed Fly resources reference each other,
+ * so `chant graph --live` reconstructs the topology and draws the App as a
+ * boundary box (the reference resolver, chant#778; containment, chant#779).
+ *
+ * Fly's relationships are app-centric and simple. `describeResources`
+ * (./describe-resources.ts) already returns the rich per-resource shape — each
+ * app-scoped resource carries its owning `app`, and a machine carries its full
+ * `config` (with `mounts`) — so, unlike AWS (chant#784), Fly needs **no**
+ * `enrichLiveAttrs`: the references are already in the observed attributes.
+ *
+ * Keyed to the `describeResources` attribute shape:
+ *   - App        → `{ app }`           (physicalId = app name)
+ *   - Machine    → `{ app, config }`   (config.mounts[].volume references a Volume)
+ *   - Volume     → `{ app, volumeName }`
+ *   - IPAddress  → `{ app, ... }`
+ *   - Certificate→ `{ app, ... }`
+ */
+export const flyReferenceCatalog: ReferenceCatalog = {
+  identities: [
+    // The App is identified by its name (also its physicalId), which every
+    // app-scoped resource carries in `app`.
+    { kind: "Fly::Machines::App", ids: ["app"] },
+    // A Volume is referenced by name; its id is already indexed via physicalId,
+    // so a mount that names either resolves.
+    { kind: "Fly::Machines::Volume", ids: ["volumeName"] },
+  ],
+  refs: [
+    // Containment: everything app-scoped lives inside its App → a boundary box.
+    { from: "Fly::Machines::Machine", path: "app", targetKind: "Fly::Machines::App", relation: "containment", label: "in app" },
+    { from: "Fly::Machines::Volume", path: "app", targetKind: "Fly::Machines::App", relation: "containment", label: "in app" },
+    { from: "Fly::Machines::IPAddress", path: "app", targetKind: "Fly::Machines::App", relation: "containment", label: "in app" },
+    { from: "Fly::Machines::Certificate", path: "app", targetKind: "Fly::Machines::App", relation: "containment", label: "in app" },
+    // Reference edge: a machine mount → the Volume it mounts.
+    { from: "Fly::Machines::Machine", path: "config.mounts[].volume", targetKind: "Fly::Machines::Volume", relation: "reference", label: "mounts" },
+  ],
+};

package/src/skills/chant-fly-patterns.md

@@ -15,9 +15,9 @@ Beyond the App and Machine covered in `chant-fly`, the lexicon models `Volume`,
 The FLY011 build check enforces the link statically: every machine mount must reference a `Volume` declared in the stack, checked across files. A mount that points at an undeclared volume fails `chant build` before anything reaches the API.
 
 ```ts
-import { App, Machine, MachineConfig, MachineGuest, Volume } from "@intentius/chant-lexicon-fly";
+import { App, Machine, MachineConfig, MachineGuest, Volume, Fly } from "@intentius/chant-lexicon-fly";
 
-export const app = new App({ name: "my-app" });
+export const app = new App({ name: "my-app", org_slug: Fly.OrgSlug });
 
 export const data = new Volume({ name: "data", region: "iad", size_gb: 10 });
 

package/src/skills/chant-fly.md

@@ -40,9 +40,9 @@ That Op runs the phases boot, build, apply, verify, and teardown against a local
 Import resource types from `@intentius/chant-lexicon-fly`. They are generated from Fly's Machines API OpenAPI spec, so `MachineConfig` is typed all the way down through guest, services, mounts, and checks.
 
 ```ts
-import { App, Machine, MachineConfig, MachineGuest } from "@intentius/chant-lexicon-fly";
+import { App, Machine, MachineConfig, MachineGuest, Fly } from "@intentius/chant-lexicon-fly";
 
-export const app = new App({ name: "my-app" });
+export const app = new App({ name: "my-app", org_slug: Fly.OrgSlug });
 
 export const web = new Machine({
   name: "web",