@intentius/chant-lexicon-fly 0.16.0

package/README.md

@@ -0,0 +1,91 @@
+# @intentius/chant-lexicon-fly
+
+The Fly.io lexicon for [chant](https://intentius.io/chant/). Declare Fly apps, machines, volumes, IPs, certificates, and secrets as typed TypeScript and apply them straight to the Fly Machines API.
+
+```bash
+npm install --save-dev @intentius/chant @intentius/chant-lexicon-fly
+```
+
+## Test it without a Fly account
+
+Fly's Machines API is emulated by [mudflaps](https://github.com/intentius/mudflaps), a stateful Fly Machines API emulator. The entire apply-and-deploy loop runs against a local mudflaps container in CI, with no Fly account and no bill. The same code then deploys to a real org by changing one endpoint, so the loop you test offline is the loop you ship.
+
+```bash
+cd examples/local-fly
+chant run fly        # boots mudflaps, applies an App + Machine, waits for started, tears down
+```
+
+## What it does
+
+chant is a type system for operations: you describe infrastructure as typed TypeScript, and each lexicon turns those declarations into real provider API calls. This one covers Fly.
+
+The resource types (`App`, `Machine`, `Volume`, `IPAddress`, `Certificate`, `Secret`) are generated from Fly's own Machines API OpenAPI spec, so they track the real API and give you full editor autocomplete. A build step lints them, and `flyApply` reconciles them against a Fly org over the Machines API (flaps) directly.
+
+It fits two kinds of user: teams running on Fly who want their infrastructure as typed, reviewed, reconciled code rather than imperative CLI calls, and platform engineers who already manage AWS, GCP, or Kubernetes through chant and want Fly in the same model.
+
+## Author infrastructure as typed code
+
+```ts
+import { App, Machine, MachineConfig, MachineGuest } from "@intentius/chant-lexicon-fly";
+
+export const app = new App({ name: "my-app" });
+
+export const web = new Machine({
+  region: "iad",
+  config: new MachineConfig({
+    image: "flyio/hellofly:latest",
+    guest: new MachineGuest({ cpu_kind: "shared", cpus: 1, memory_mb: 256 }),
+  }),
+});
+```
+
+`MachineConfig` is typed all the way down through guest, services, mounts, and checks, because the whole graph is generated from the Machines API spec.
+
+## Apply without a state file
+
+`flyApply` speaks the Machines API directly. There is no `flyctl` shell-out and no state file to store, lock, or keep in sync. It reconciles what you declared against what is actually running:
+
+- Creates and updates machines, then waits each one to `started` over the Machines API `/wait` endpoint.
+- Prunes only what chant owns. Every machine chant creates carries a `managed-by: chant` marker, and a machine without it is never modified or deleted, so the applier is safe to point at an app that also holds resources you manage elsewhere.
+- Speaks the Machines API lease protocol: acquire a lease, send the nonce on each mutation, re-acquire and retry if the lease is lost, so concurrent operators stay out of each other's way.
+
+The endpoint is a single switch. Set `FLY_FLAPS_BASE_URL` (or pass an `endpoint`) to choose between a real Fly org and a local emulator with no code change.
+
+## Catch mistakes at build time
+
+Lint rules run during `chant build`, before anything reaches the API:
+
+- `region` must be a real Fly region.
+- Guest sizing (`cpu_kind` / `cpus` / `memory_mb`) must be a valid combination.
+- Every machine mount must reference a `Volume` declared in the stack, checked across files.
+- Secret values may not be written inline; they belong in a `Secret` or a reference.
+
+## The deploy Op
+
+The lexicon ships a deploy Op that runs the phases boot, build, apply, verify, and teardown, and a runnable [`examples/local-fly`](../../examples/local-fly) starter. As shown above, `chant run fly` boots mudflaps, builds the plan, applies the App and Machine, waits for the machine to reach `started`, and tears the emulator down. Drop the local endpoint and set `FLY_API_TOKEN`, and the same Op deploys to a real Fly org.
+
+## Compared to a Terraform provider for Fly
+
+|              | Terraform for Fly                        | This lexicon                                            |
+| ------------ | ---------------------------------------- | ------------------------------------------------------- |
+| **State**    | A `.tfstate` to store, lock, and back up | None; reconciles from live state + the ownership marker |
+| **Language** | HCL                                      | TypeScript, types generated from the Machines API spec  |
+| **Testing**  | Against a real Fly org                   | Offline against the mudflaps emulator, in CI            |
+
+The same code applies to a local emulator and to a real Fly org; the only difference is the endpoint.
+
+## Agent skill
+
+The agent-facing entry point is the `chant-fly` skill: a short operational playbook that walks an agent through authoring an `App` and `Machine`, linting with `chant build`, and reconciling over the Machines API with `flyApply`, including the `FLY_FLAPS_BASE_URL` switch between mudflaps and a real org. It ships with two companions, `chant-fly-patterns` (volumes, IPs, certificates, apply-only secrets, and the ownership model) and `chant-fly-ops` (waiting, leases, prune, and teardown). The skill sources live in [`src/skills/`](src/skills/).
+
+## Related packages
+
+| Package                                                                                    | Role                                  |
+| ------------------------------------------------------------------------------------------ | ------------------------------------- |
+| [@intentius/chant](https://www.npmjs.com/package/@intentius/chant)                         | Core type system, CLI, build pipeline |
+| [@intentius/chant-lexicon-aws](https://www.npmjs.com/package/@intentius/chant-lexicon-aws) | AWS CloudFormation lexicon            |
+| [@intentius/chant-lexicon-gcp](https://www.npmjs.com/package/@intentius/chant-lexicon-gcp) | GCP Deployment Manager lexicon        |
+
+## License
+
+See the main project LICENSE file.

package/dist/codegen/docs-cli.d.ts

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

package/dist/codegen/docs-cli.d.ts.map

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

package/dist/codegen/docs.d.ts

@@ -0,0 +1,27 @@
+/**
+ * fly (Machines API / "flaps") documentation generator.
+ *
+ * Calls the core docsPipeline with fly-specific config: service grouping and
+ * overview content. Produces a standalone Starlight docs site at
+ * lexicons/fly/docs/, like the aws and gcp lexicons.
+ */
+/**
+ * Group a fly resource type into a service bucket for the reference sidebar.
+ * fly type names are `Fly::Machines::<Kind>`, so the middle segment is always
+ * "Machines"; grouping by the leaf kind gives a more useful split (Apps,
+ * Machines, Storage, Networking, Secrets).
+ */
+export declare function serviceFromType(resourceType: string): string;
+/**
+ * The reference doc URL for a fly resource type. The Machines API (flaps) is
+ * documented at docs.machines.dev, tagged by resource; resources flaps does not
+ * own (public IPs, certificates) link to the matching fly.io docs page.
+ */
+export declare function resourceTypeUrl(resourceType: string): string;
+/**
+ * Generate documentation for the fly Machines lexicon.
+ */
+export declare function generateDocs(options?: {
+    verbose?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=docs.d.ts.map

package/dist/codegen/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/codegen/docs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAsBH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAiB5D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAkB5D;AAsED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA0DjF"}

package/dist/codegen/generate-cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for fly lexicon generation.
+ */
+export {};
+//# sourceMappingURL=generate-cli.d.ts.map

package/dist/codegen/generate-cli.d.ts.map

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

package/dist/codegen/generate-lexicon.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lexicon JSON generator — produces lexicon-fly.json with metadata for the
+ * fly resource and property types.
+ */
+import type { PropertyConstraints } from "@intentius/chant/codegen/json-schema";
+import type { FlyParseResult } from "../spec/parse.js";
+import type { NamingStrategy } from "./naming.js";
+export interface FlyLexiconEntry {
+    resourceType: string;
+    kind: "resource" | "property";
+    lexicon: "fly";
+    constraints?: Record<string, PropertyConstraints>;
+}
+/**
+ * Generate the lexicon-fly.json content.
+ */
+export declare function generateLexiconJSON(results: FlyParseResult[], naming: NamingStrategy): string;
+//# sourceMappingURL=generate-lexicon.d.ts.map

package/dist/codegen/generate-lexicon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-lexicon.d.ts","sourceRoot":"","sources":["../../src/codegen/generate-lexicon.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAG/C,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;IAC9B,OAAO,EAAE,KAAK,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;CACnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CA8B7F"}

package/dist/codegen/generate-typescript.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with the fly
+ * resource classes (App, Machine, Volume) and their property-type classes.
+ */
+import type { FlyParseResult } from "../spec/parse.js";
+import type { NamingStrategy } from "./naming.js";
+/**
+ * Generate the complete .d.ts file content.
+ */
+export declare function generateTypeScriptDeclarations(results: FlyParseResult[], naming: NamingStrategy): string;
+//# sourceMappingURL=generate-typescript.d.ts.map

package/dist/codegen/generate-typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-typescript.d.ts","sourceRoot":"","sources":["../../src/codegen/generate-typescript.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAe/C;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CA4CxG"}

package/dist/codegen/generate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fly generation pipeline — uses core generatePipeline with fly-specific
+ * fetch, parse, naming, and generation callbacks.
+ */
+import { type GenerateOptions, type GenerateResult } from "@intentius/chant/codegen/generate";
+export type { GenerateResult };
+/**
+ * Run the full fly generation pipeline.
+ */
+export declare function generate(opts?: GenerateOptions): Promise<GenerateResult>;
+/**
+ * Write generated artifacts to disk.
+ */
+export declare function writeGeneratedFiles(result: GenerateResult, baseDir: string): void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/codegen/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EAEpB,MAAM,mCAAmC,CAAC;AAY3C,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoClF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAUjF"}

package/dist/codegen/naming.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Fly naming strategy — maps Fly::Machines::{Kind} type names to
+ * user-friendly TypeScript class names.
+ */
+import { NamingStrategy as CoreNamingStrategy } from "@intentius/chant/codegen/naming";
+import { type FlyParseResult } from "../spec/parse.js";
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+/**
+ * Fly-specific naming strategy. Extends the core strategy with the fly config.
+ */
+export declare class NamingStrategy extends CoreNamingStrategy {
+    constructor(results: FlyParseResult[]);
+}
+//# sourceMappingURL=naming.d.ts.map

package/dist/codegen/naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../src/codegen/naming.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,cAAc,IAAI,kBAAkB,EAGrC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAElF,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAqBnF;;GAEG;AACH,qBAAa,cAAe,SAAQ,kBAAkB;gBACxC,OAAO,EAAE,cAAc,EAAE;CAOtC"}

package/dist/codegen/package.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Package the fly lexicon for distribution.
+ */
+export declare function packageLexicon(options?: {
+    verbose?: boolean;
+    force?: boolean;
+}): Promise<{
+    spec: import("packages/core/src").BundleSpec;
+    stats: {
+        resources: number;
+        properties: number;
+        enums: number;
+        ruleCount: number;
+        skillCount: number;
+    };
+}>;
+//# sourceMappingURL=package.d.ts.map

package/dist/codegen/package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.d.ts","sourceRoot":"","sources":["../../src/codegen/package.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;;GAepF"}

package/dist/composites/fly-deploy.d.ts

@@ -0,0 +1,110 @@
+/**
+ * fly deploy Op (#744) — the integration proof: `boot → build → flyApply → wait
+ * → teardown` on the local executor. The peer of the aws/gcp deploy Ops in
+ * `examples/local-cloud-trio`, for a single cloud.
+ *
+ * The phases compose modeled activities, no raw shell:
+ *   Emulator  boot mudflaps (the Fly Machines API fake) via `flapsUp`
+ *   Build     run the project's `build:fly` npm script → the serialized plan
+ *   Apply     `flyApply` the plan straight to flaps (creates App + Machine and
+ *             waits each machine to `started` via `/wait`)
+ *   Verify    GET the app's machines and assert one reached `started`
+ *   Teardown  stop and remove the mudflaps container via `flapsDown`
+ *
+ * The activity steps are the generic `activity(fn, args)` builder tagged with
+ * the exported activity function names the fly lexicon contributes
+ * (`flapsUp`/`flapsDown`/`flyApply` from `src/op/activities`). The core activity
+ * registry resolves them by name when a project lists the `fly` lexicon, so
+ * these typed builders give `gcpApply()`-style DX without a core change.
+ *
+ * D3 (local vs real Fly): the Apply step's flaps endpoint defaults to local
+ * mudflaps (`http://localhost:4280`). Pass `endpoint: null` to drop the override
+ * and let `flyApply` fall through to `FLY_FLAPS_BASE_URL` / real Fly (with a
+ * `FLY_API_TOKEN`).
+ */
+import type { OpResource } from "@intentius/chant/op";
+import type { ActivityStep } from "@intentius/chant/op";
+/** The local mudflaps endpoint the deploy Op targets by default. */
+export declare const LOCAL_FLAPS_ENDPOINT = "http://localhost:4280";
+/** Options accepted by the mudflaps lifecycle step builders. */
+export interface FlapsStepOpts {
+    /** Container name. Default: `chant-mudflaps`. */
+    name?: string;
+    /** Host port mapped to the emulator's `:4280`. Default: `4280`. */
+    port?: number;
+    /** Image. Default: `ghcr.io/intentius/mudflaps:0.3.0`. */
+    image?: string;
+    /** Readiness timeout in ms. */
+    timeoutMs?: number;
+    /** Health poll interval in ms. */
+    intervalMs?: number;
+    /** Activity profile override. */
+    profile?: ActivityStep["profile"];
+}
+/**
+ * Boot a local mudflaps (Fly Machines API emulator) in Docker and point the
+ * apply step at it — the typed twin of `flociGcpUp` for flaps. Resolves to the
+ * `flapsUp` activity (#740). Defaults to the `longInfra` profile (the image may
+ * pull); override via `opts.profile`.
+ */
+export declare const flapsUp: (opts?: FlapsStepOpts) => ActivityStep;
+/** Stop and remove the local mudflaps container. Resolves to the `flapsDown` activity. Defaults to the `fastIdempotent` profile (override via `opts.profile`). */
+export declare const flapsDown: (opts?: FlapsStepOpts) => ActivityStep;
+/** Options for the flaps apply step (mirror `FlyApplyArgs`, minus `planPath`). */
+export interface FlyApplyStepOpts {
+    /** flaps endpoint override (D3). Default: `FLY_FLAPS_BASE_URL` env, else real Fly. */
+    endpoint?: string;
+    /** Bearer token for real Fly. Default: `FLY_API_TOKEN`. mudflaps ignores it. */
+    token?: string;
+    /** Prune declared-then-removed resources (D2). Destructive — off by default. */
+    prune?: boolean;
+    /** Wait-loop tuning (mainly for tests). */
+    wait?: Record<string, unknown>;
+    /** Activity profile override. */
+    profile?: ActivityStep["profile"];
+}
+/**
+ * Apply the serialized flaps plan straight to the Machines API — the typed twin
+ * of `gcpApply` for fly. Resolves to the `flyApply` activity (#739): create
+ * App + Machine, wait each machine to `started`, prune owned-only when asked.
+ * Defaults to the `longInfra` profile (override via `opts.profile`).
+ */
+export declare const flyApplyStep: (planPath: string, opts?: FlyApplyStepOpts) => ActivityStep;
+/** Options for {@link flyDeploy}. */
+export interface FlyDeployOpts {
+    /** Op name (the `chant run <name>` target). Default: `fly`. */
+    name?: string;
+    /** Op overview line. */
+    overview?: string;
+    /** Temporal task queue (unused by the local executor). Default: `local-fly`. */
+    taskQueue?: string;
+    /** Directory the `build:fly` script and plan path are relative to. Default: `.`. */
+    path?: string;
+    /** npm build script to run. Default: `build:fly`. */
+    buildScript?: string;
+    /** Path to the serialized flaps plan the build writes. Default: `dist/fly.json`. */
+    planPath?: string;
+    /**
+     * flaps endpoint the apply + verify steps target (D3). Defaults to local
+     * mudflaps ({@link LOCAL_FLAPS_ENDPOINT}). Pass `null` to drop the override so
+     * `flyApply` targets real Fly via `FLY_FLAPS_BASE_URL` / a `FLY_API_TOKEN`.
+     */
+    endpoint?: string | null;
+    /**
+     * App name for the Verify step. When set (with a local `endpoint`), the Op GETs
+     * the app's machines and asserts one reached `started`. Omitted → no Verify
+     * step (the Apply step still waits each machine to `started`).
+     */
+    app?: string;
+    /** Prune declared-then-removed resources on apply (D2). Off by default. */
+    prune?: boolean;
+    /** Wait-loop tuning passed through to `flyApply` (mainly for tests). */
+    wait?: Record<string, unknown>;
+}
+/**
+ * Build a fly deploy Op: boot mudflaps, build the plan, apply App + Machine,
+ * verify the machine reached `started`, tear the emulator down. See the module
+ * docstring for the phase layout and the D3 endpoint story.
+ */
+export declare function flyDeploy(opts?: FlyDeployOpts): InstanceType<typeof OpResource>;
+//# sourceMappingURL=fly-deploy.d.ts.map

package/dist/composites/fly-deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fly-deploy.d.ts","sourceRoot":"","sources":["../../src/composites/fly-deploy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,oEAAoE;AACpE,eAAO,MAAM,oBAAoB,0BAA0B,CAAC;AAE5D,gEAAgE;AAChE,MAAM,WAAW,aAAa;IAC5B,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,OAAO,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;CACnC;AAED;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,aAAa,KAAG,YAG9C,CAAC;AAEF,kKAAkK;AAClK,eAAO,MAAM,SAAS,GAAI,OAAO,aAAa,KAAG,YAGhD,CAAC;AAEF,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC/B,sFAAsF;IACtF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,iCAAiC;IACjC,OAAO,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;CACnC;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,EAAE,OAAO,gBAAgB,KAAG,YAGxE,CAAC;AAEF,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,GAAE,aAAkB,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAyCnF"}

package/dist/describe-resources.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Live introspection of Fly (flaps) resources — the read-back seam for chant's
+ * plan/drift machinery (#767).
+ *
+ * The write path (flyApply, #739/#741) already GETs live state to decide
+ * create/update/noop and to prune owned orphans. This surfaces that same read
+ * side through the standard `describeResources` seam so core's change set
+ * (packages/core/src/lifecycle/change-set.ts) and `chant lifecycle plan` can see
+ * live Fly state and classify create/update/delete/adopt/noop.
+ *
+ * Peer of gcp/aws describe-resources: list what is live, key it by chant entity
+ * name, attach an ownership verdict. Two-tier ownership, matching the applier
+ * (#743):
+ *
+ *   - Machines carry the primary marker (`managed-by: chant`,
+ *     FLY_METADATA_OWNERSHIP_KEYS), so their verdict is per-resource: `owned`
+ *     when `isChantOwned(config.metadata)`, else `foreign`.
+ *   - Volumes, IPs, and certificates carry no marker channel, so their boundary
+ *     is the app (#741/#743): everything under a chant-managed app (one carrying
+ *     the marker via its machines) is `owned`. When the `owned` filter asks for
+ *     those types, this logs that ownership is inferred at the app boundary
+ *     rather than silently returning everything, per the seam contract.
+ *
+ * Endpoint + auth reuse the applier verbatim (resolveEndpoint /
+ * FLY_FLAPS_BASE_URL / FLY_API_TOKEN), so plan reads the same mudflaps or
+ * real-Fly target flyApply writes. Secrets are apply-only (D7): flaps returns
+ * only a digest, so they never enter a diff and are excluded here.
+ */
+import type { ResourceMetadata } from "@intentius/chant/lexicon";
+import { type ChangeSet } from "@intentius/chant/lifecycle/change-set";
+import { type FlyHttp } from "./op/activities/fly-apply.js";
+export interface DescribeResourcesOptions {
+    environment: string;
+    buildOutput: string;
+    entityNames: string[];
+    entities: Map<string, {
+        entityType: string;
+        props: Record<string, unknown>;
+    }>;
+    /** Restrict to chant-owned resources (#119). */
+    owned?: boolean;
+    /** flaps endpoint override (tests). Defaults to resolveEndpoint() → FLY_FLAPS_BASE_URL. */
+    endpoint?: string;
+}
+/**
+ * List live Fly resources over flaps and return them keyed by chant entity name,
+ * each tagged with an ownership verdict the core change set reads to decide
+ * whether an orphan is a delete (owned) or an adopt candidate (foreign). Reused
+ * by `flyPlugin.describeResources`.
+ *
+ * `http` is injectable for tests; the default reuses the applier's fetch client
+ * (bearer token from FLY_API_TOKEN).
+ */
+export declare function describeResources(options: DescribeResourcesOptions, http?: FlyHttp, signal?: AbortSignal): Promise<Record<string, ResourceMetadata>>;
+/**
+ * Read-only plan (#767 §4): a `flyApply` dry-run. Reads live state via
+ * {@link describeResources}, promotes it to core's typed change set, then
+ * refines each declared+live machine's update/noop verdict with the applier's
+ * own `configEqual`, so the plan matches exactly what a subsequent `flyApply`
+ * would do — never mutating. `renderChangeSet` gives the human view.
+ *
+ * The core change set already computes create/delete/adopt/noop from
+ * declared-vs-live + ownership; the `configEqual` refinement adds the
+ * declared-vs-live *config* comparison for machines (core's own update signal is
+ * snapshot-relative, which a stateless dry-run has no snapshot for).
+ */
+export declare function flyPlan(options: DescribeResourcesOptions & {
+    /** Previous snapshot resources, when reconciling drift since a snapshot. */
+    observedThen?: Record<string, ResourceMetadata>;
+}, http?: FlyHttp, signal?: AbortSignal): Promise<{
+    changeSet: ChangeSet;
+    rendered: string;
+}>;
+//# sourceMappingURL=describe-resources.d.ts.map

package/dist/describe-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-resources.d.ts","sourceRoot":"","sources":["../src/describe-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAqBL,KAAK,OAAO,EAIb,MAAM,2BAA2B,CAAC;AAcnC,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,gDAAgD;IAChD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAeD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,wBAAwB,EACjC,IAAI,GAAE,OAA0B,EAChC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CA0M3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,OAAO,CAC3B,OAAO,EAAE,wBAAwB,GAAG;IAClC,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACjD,EACD,IAAI,GAAE,OAA0B,EAChC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA8BrD"}

package/dist/detect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Template detection for the fly lexicon.
+ *
+ * `chant import` parses a template file as JSON and asks each installed lexicon
+ * whether it recognizes the shape. fly's importable source is flaps JSON — the
+ * Machines API surface the #738 serializer emits and the applier POSTs. Three
+ * shapes are recognized:
+ *
+ *   1. The serializer plan: an object keyed by entity name whose values are
+ *      `{ endpoint, method, body }` flaps requests (what #738 produces).
+ *   2. A machine, a machines listing, or an app-with-machines bundle: what
+ *      `GET /v1/apps/{app}/machines` returns, or a single machine create body.
+ *   3. An app: a create body (`{ app_name }`) or the `GET /v1/apps/{app}` shape.
+ */
+/** The serializer's whole output: entity name → flaps request. */
+export declare function isSerializerPlan(v: unknown): boolean;
+/** A live or create-body machine: carries a `config` object, or the id+state+region GET shape. */
+export declare function isMachineObject(v: unknown): boolean;
+/** An app: a create body (`app_name`) or the `GET /v1/apps/{app}` shape (`name` + machine_count/organization/status). */
+export declare function isAppObject(v: unknown): boolean;
+export declare function detectTemplate(data: unknown): boolean;
+//# sourceMappingURL=detect.d.ts.map

package/dist/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAYH,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAIpD;AAED,kGAAkG;AAClG,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAInD;AAED,yHAAyH;AACzH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAO/C;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAcrD"}

package/dist/export-resources.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Live export for the fly lexicon — implements `LexiconPlugin.exportResources()`
+ * so `chant import --from <fly-env>` regenerates existing Fly apps and machines
+ * as chant TypeScript.
+ *
+ * Reads live flaps state and hands it to the pure `./import/live-export`
+ * helpers, which strip server-written fields to the authored shape and map it to
+ * import IR via `FlyParser`. Endpoint + auth reuse the applier verbatim
+ * (`resolveEndpoint` / `defaultFlyHttp` → FLY_FLAPS_BASE_URL / FLY_API_TOKEN),
+ * and the machine listing reuses the applier's `listMachines`, so export reads
+ * the same target `flyApply` writes and `describeResources` observes.
+ *
+ * Which apps are exported: an app named by the selector, else `FLY_APP_NAME`,
+ * else every app in the org (`GET /v1/apps?org_slug=<FLY_ORG>`). All flaps I/O
+ * lives here; cleaning and IR-building are pure in `./import/live-export`.
+ */
+import type { ExportedTemplate, ResourceSelector } from "@intentius/chant/lexicon";
+import { type FlyHttp } from "./op/activities/fly-apply.js";
+export declare function exportResources(options: {
+    environment: string;
+    selector?: ResourceSelector;
+    owned?: boolean;
+    verbatim?: boolean;
+}, http?: FlyHttp, signal?: AbortSignal): Promise<ExportedTemplate>;
+//# sourceMappingURL=export-resources.d.ts.map

package/dist/export-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-resources.d.ts","sourceRoot":"","sources":["../src/export-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAIL,KAAK,OAAO,EAEb,MAAM,2BAA2B,CAAC;AA8CnC,wBAAsB,eAAe,CACnC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,EACD,IAAI,GAAE,OAA0B,EAChC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,gBAAgB,CAAC,CA2C3B"}

package/dist/generated/index.d.ts

@@ -0,0 +1,42 @@
+export declare const App: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Certificate: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const IPAddress: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Machine: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Secret: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const Volume: new (props: Record<string, unknown>, attributes?: Record<string, unknown>) => import("packages/core/src").Declarable & Record<string, string>;
+export declare const ContainerConfig: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const ContainerDependency: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const ContainerHealthcheck: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const DNSConfig: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const DnsForwardRule: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const DnsOption: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const EnvFrom: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const ExecHealthcheck: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const File: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const HTTPHealthcheck: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const HTTPOptions: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const HTTPResponseOptions: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineCacheDrive: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineCheck: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineConfig: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineGuest: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineHTTPHeader: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineInit: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineMetrics: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineMount: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachinePort: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineProcess: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineRestart: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineRootfs: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineSecret: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineService: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineServiceCheck: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineServiceConcurrency: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const MachineSpot: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const ProxyProtoOptions: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const ReplayCache: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const Static: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const StopConfig: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const TCPHealthcheck: new (props: Record<string, unknown>) => Record<string, unknown>;
+export declare const TLSOptions: new (props: Record<string, unknown>) => Record<string, unknown>;
+//# sourceMappingURL=index.d.ts.map

package/dist/generated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generated/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG,+IAAqN,CAAC;AACtO,eAAO,MAAM,WAAW,+IAAqV,CAAC;AAC9W,eAAO,MAAM,SAAS,+IAA6G,CAAC;AACpI,eAAO,MAAM,OAAO,+IAA+V,CAAC;AACpX,eAAO,MAAM,MAAM,+IAAwI,CAAC;AAC5J,eAAO,MAAM,MAAM,+IAAgZ,CAAC;AAEpa,eAAO,MAAM,eAAe,iEAA0D,CAAC;AACvF,eAAO,MAAM,mBAAmB,iEAA8D,CAAC;AAC/F,eAAO,MAAM,oBAAoB,iEAA+D,CAAC;AACjG,eAAO,MAAM,SAAS,iEAAoD,CAAC;AAC3E,eAAO,MAAM,cAAc,iEAAyD,CAAC;AACrF,eAAO,MAAM,SAAS,iEAAoD,CAAC;AAC3E,eAAO,MAAM,OAAO,iEAAkD,CAAC;AACvE,eAAO,MAAM,eAAe,iEAA0D,CAAC;AACvF,eAAO,MAAM,IAAI,iEAA+C,CAAC;AACjE,eAAO,MAAM,eAAe,iEAA0D,CAAC;AACvF,eAAO,MAAM,WAAW,iEAAsD,CAAC;AAC/E,eAAO,MAAM,mBAAmB,iEAA8D,CAAC;AAC/F,eAAO,MAAM,iBAAiB,iEAA4D,CAAC;AAC3F,eAAO,MAAM,YAAY,iEAAuD,CAAC;AACjF,eAAO,MAAM,aAAa,iEAAwD,CAAC;AACnF,eAAO,MAAM,YAAY,iEAAuD,CAAC;AACjF,eAAO,MAAM,iBAAiB,iEAA4D,CAAC;AAC3F,eAAO,MAAM,WAAW,iEAAsD,CAAC;AAC/E,eAAO,MAAM,cAAc,iEAAyD,CAAC;AACrF,eAAO,MAAM,YAAY,iEAAuD,CAAC;AACjF,eAAO,MAAM,WAAW,iEAAsD,CAAC;AAC/E,eAAO,MAAM,cAAc,iEAAyD,CAAC;AACrF,eAAO,MAAM,cAAc,iEAAyD,CAAC;AACrF,eAAO,MAAM,aAAa,iEAAwD,CAAC;AACnF,eAAO,MAAM,aAAa,iEAAwD,CAAC;AACnF,eAAO,MAAM,cAAc,iEAAyD,CAAC;AACrF,eAAO,MAAM,mBAAmB,iEAA8D,CAAC;AAC/F,eAAO,MAAM,yBAAyB,iEAAoE,CAAC;AAC3G,eAAO,MAAM,WAAW,iEAAsD,CAAC;AAC/E,eAAO,MAAM,iBAAiB,iEAA4D,CAAC;AAC3F,eAAO,MAAM,WAAW,iEAAsD,CAAC;AAC/E,eAAO,MAAM,MAAM,iEAAiD,CAAC;AACrE,eAAO,MAAM,UAAU,iEAAqD,CAAC;AAC7E,eAAO,MAAM,cAAc,iEAAyD,CAAC;AACrF,eAAO,MAAM,UAAU,iEAAqD,CAAC"}

package/dist/generated/runtime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runtime factory constructors — re-exported from core.
+ */
+export { createResource, createProperty } from "@intentius/chant/runtime";
+//# sourceMappingURL=runtime.d.ts.map

package/dist/generated/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/generated/runtime.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/import/generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * flaps TypeScript generator.
+ *
+ * Converts import IR from {@link FlyParser} into typed chant TypeScript:
+ * `import { App, Machine, ... } from "@intentius/chant-lexicon-fly";` followed by
+ * `export const <var> = new <Class>({ ... });`.
+ *
+ * fly's nested config types (`MachineConfig`, `MachineGuest`, `MachineService`,
+ * ...) are property declarables — classes with an empty instance shape — so a
+ * bare object literal would trip TypeScript's excess-property check against the
+ * declared parameter type. Wherever a field's declared type is one of those
+ * classes, the value is wrapped in `new <Class>({ ... })` (recursively), which is
+ * the same authoring surface `chant init` scaffolds and the serializer walks back
+ * to the identical flaps body.
+ */
+import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
+import type { TemplateIR } from "@intentius/chant/import/parser";
+export declare class FlyGenerator implements TypeScriptGenerator {
+    generate(ir: TemplateIR): GeneratedFile[];
+}
+//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/import/generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAuFjE,qBAAa,YAAa,YAAW,mBAAmB;IACtD,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,aAAa,EAAE;CAyB1C"}