@intentius/chant-lexicon-fly 0.124.31 → 0.124.32

package/dist/describe-resources.js

@@ -0,0 +1,443 @@
+/**
+ * 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 { normalizeObservation, observation, unobservedAll } from "@intentius/chant/observation";
+import { readOwnership } from "@intentius/chant/ownership";
+import { FLY_METADATA_OWNERSHIP_KEYS } from "./ownership.js";
+import { readMachineRelease } from "./release-metadata.js";
+import { buildChangeSet, renderChangeSet, } from "@intentius/chant/lifecycle/change-set";
+import { resolveEndpoint, defaultFlyHttp, parsePlan, isAppRequest, isMachineRequest, isVolumeRequest, isIpRequest, isCertRequest, appNameFromRequest, machineAppSegment, resourceAppSegment, resolveApp, isChantOwned, configEqual, listMachines, listVolumes, listIps, listCerts, ipType, declaredIpType, } from "./op/activities/fly-apply.js";
+/** The chant entity types the fly serializer emits, for the metadata `type` field. */
+const TYPE = {
+    app: "Fly::Machines::App",
+    machine: "Fly::Machines::Machine",
+    volume: "Fly::Machines::Volume",
+    ip: "Fly::Machines::IPAddress",
+    cert: "Fly::Machines::Certificate",
+};
+/** Live machine states that mean the machine is gone or on its way out — not live. */
+const TERMINAL_STATES = new Set(["destroyed", "destroying"]);
+function pruneUndefined(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+/** The serialized machine name flaps stores: an explicit `body.name`, else the entity name (mirrors applyMachine). */
+function serializedName(req, entityName) {
+    return typeof req.body.name === "string" && req.body.name ? req.body.name : entityName;
+}
+/** The release attributes of a Machine whose metadata names one (#2736). */
+function releaseAttributes(metadata) {
+    const release = readMachineRelease(metadata);
+    return release ? { digest: release.digest, release } : {};
+}
+/** A string prop, or undefined. */
+function stringProp(props, key) {
+    const v = props[key];
+    return typeof v === "string" && v ? v : undefined;
+}
+/**
+ * A plan rebuilt from declared entities (#2736), for a caller that has the
+ * entities and no serialized build. It holds only what a read is keyed by:
+ * each App's name, and each Machine, Volume, IP and Certificate with the App it
+ * belongs to (an `app` prop naming it, else the sole declared App). Returns ""
+ * when there are no entities to rebuild from.
+ */
+export function planFromEntities(entities) {
+    const plan = {};
+    const apps = [];
+    for (const [name, { entityType, props }] of entities) {
+        if (entityType !== TYPE.app)
+            continue;
+        const appName = stringProp(props, "name") ?? name;
+        apps.push(appName);
+        plan[name] = { endpoint: "/v1/apps", method: "POST", body: { app_name: appName } };
+    }
+    const soleApp = apps.length === 1 ? apps[0] : "{app}";
+    const owning = (props) => {
+        const app = props.app;
+        if (typeof app === "string" && app)
+            return app;
+        const ref = app && typeof app === "object" ? app.props : undefined;
+        return (ref && stringProp(ref, "name")) ?? soleApp;
+    };
+    for (const [name, { entityType, props }] of entities) {
+        const app = owning(props);
+        const base = `/v1/apps/${app}`;
+        if (entityType === TYPE.machine) {
+            plan[name] = { endpoint: `${base}/machines`, method: "POST", body: { name: stringProp(props, "name") ?? name } };
+        }
+        else if (entityType === TYPE.volume) {
+            plan[name] = { endpoint: `${base}/volumes`, method: "POST", body: { name: stringProp(props, "name") ?? name } };
+        }
+        else if (entityType === TYPE.ip) {
+            plan[name] = { endpoint: `${base}/ip_assignments`, method: "POST", body: { type: props.type } };
+        }
+        else if (entityType === TYPE.cert) {
+            plan[name] = { endpoint: `${base}/certificates/acme`, method: "POST", body: { hostname: props.hostname } };
+        }
+    }
+    return Object.keys(plan).length ? JSON.stringify(plan) : "";
+}
+/**
+ * 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 async function describeResources(options, http = defaultFlyHttp(), signal) {
+    const result = {};
+    const unobserved = {};
+    // `chant components status --live` hands over the declared entities with no
+    // serialized build (#2736): the plan is rebuilt from their props, enough to
+    // key each read by. Without either there is nothing to key a read by, so
+    // chant never asks flaps anything — every declared entity is unobserved, not
+    // absent (#1089). Returning an empty map here used to plan a create for each.
+    const buildOutput = options.buildOutput || planFromEntities(options.entities);
+    if (!buildOutput) {
+        return observation(result, unobservedAll(options.entities.keys(), "read-failed", "no fly plan in the build output to read back", options.entities));
+    }
+    let plan;
+    try {
+        plan = parsePlan(buildOutput);
+    }
+    catch (err) {
+        return observation(result, unobservedAll(options.entities.keys(), "read-failed", `build output is not a readable fly plan: ${err instanceof Error ? err.message : String(err)}`, options.entities));
+    }
+    const ctx = { base: resolveEndpoint({ endpoint: options.endpoint }) };
+    const owned = options.owned ?? false;
+    const entities = options.entities;
+    const typeOf = (entityName, fallback) => entities.get(entityName)?.entityType ?? fallback;
+    // Classify the declared plan (mirrors flyApply's dispatch). Secrets are
+    // apply-only (D7) and never enter a diff, so they are not collected.
+    const appReqs = [];
+    const machineReqs = [];
+    const volumeReqs = [];
+    const ipReqs = [];
+    const certReqs = [];
+    for (const [entityName, req] of Object.entries(plan)) {
+        if (isAppRequest(req))
+            appReqs.push([entityName, req]);
+        else if (isMachineRequest(req))
+            machineReqs.push([entityName, req]);
+        else if (isVolumeRequest(req))
+            volumeReqs.push([entityName, req]);
+        else if (isIpRequest(req))
+            ipReqs.push([entityName, req]);
+        else if (isCertRequest(req))
+            certReqs.push([entityName, req]);
+    }
+    const appNames = appReqs.map(([, r]) => appNameFromRequest(r));
+    const soleApp = appNames.length === 1 ? appNames[0] : undefined;
+    const owningApp = (req, segment) => {
+        try {
+            return resolveApp(segment(req.endpoint), soleApp);
+        }
+        catch {
+            return undefined; // unresolved {app} placeholder — nothing to query
+        }
+    };
+    // Reverse maps: a live resource's natural key → the chant entity that declares
+    // it, so a declared+live resource keys back to the entity a re-apply touches;
+    // an undeclared live resource falls through to its natural key (an orphan).
+    const appEntityByName = new Map();
+    for (const [entityName, req] of appReqs)
+        appEntityByName.set(appNameFromRequest(req), entityName);
+    const machineEntity = new Map(); // `${app} ${name}` → entityName
+    const volumeEntity = new Map(); // `${app} ${name}`
+    const ipEntity = new Map(); // `${app} ${family}`
+    const certEntity = new Map(); // `${app} ${hostname}`
+    const appsToQuery = new Set(appNames);
+    /** An entity whose owning app can't be resolved is never queried — a hole, not an absence (#1089). */
+    const unresolvedApp = (entityName) => {
+        const type = options.entities.get(entityName)?.entityType;
+        unobserved[entityName] = {
+            ...(type ? { type } : {}),
+            reason: "read-failed",
+            detail: "owning app could not be resolved from the plan (unresolved app placeholder)",
+        };
+    };
+    for (const [entityName, req] of machineReqs) {
+        const app = owningApp(req, machineAppSegment);
+        if (!app) {
+            unresolvedApp(entityName);
+            continue;
+        }
+        appsToQuery.add(app);
+        machineEntity.set(`${app} ${serializedName(req, entityName)}`, entityName);
+    }
+    for (const [entityName, req] of volumeReqs) {
+        const app = owningApp(req, resourceAppSegment);
+        if (!app) {
+            unresolvedApp(entityName);
+            continue;
+        }
+        appsToQuery.add(app);
+        volumeEntity.set(`${app} ${serializedName(req, entityName)}`, entityName);
+    }
+    for (const [entityName, req] of ipReqs) {
+        const app = owningApp(req, resourceAppSegment);
+        if (!app) {
+            unresolvedApp(entityName);
+            continue;
+        }
+        appsToQuery.add(app);
+        ipEntity.set(`${app} ${declaredIpType(req.body.type)}`, entityName);
+    }
+    for (const [entityName, req] of certReqs) {
+        const app = owningApp(req, resourceAppSegment);
+        if (!app) {
+            unresolvedApp(entityName);
+            continue;
+        }
+        appsToQuery.add(app);
+        certEntity.set(`${app} ${String(req.body.hostname ?? "")}`, entityName);
+    }
+    /**
+     * The `owned` filter withholds a live resource; it never proves one absent
+     * (#1089). When the withheld resource is one a chant entity declares, record
+     * the hole — dropping it silently is what turned "exists, but foreign" into a
+     * proposed create. An undeclared live resource has no declared axis to
+     * misreport, so it is simply not returned.
+     */
+    const withheld = (entityName, detail) => {
+        const declaredType = entityName ? options.entities.get(entityName)?.entityType : undefined;
+        if (!entityName || !declaredType)
+            return;
+        unobserved[entityName] = { type: declaredType, reason: "filtered", detail };
+    };
+    /** Declared entities of one app whose breadth read never completed. */
+    const breadthEntitiesOf = (app) => {
+        const prefix = `${app} `;
+        const names = [];
+        for (const map of [volumeEntity, ipEntity, certEntity]) {
+            for (const [key, entityName] of map)
+                if (key.startsWith(prefix))
+                    names.push(entityName);
+        }
+        return names;
+    };
+    // The app-boundary log fires at most once per call, and only when the `owned`
+    // filter reaches the metadata-less types (mirrors aws's degrade-to-log line).
+    let loggedBoundary = false;
+    const noteBoundaryInference = () => {
+        if (loggedBoundary || !owned)
+            return;
+        loggedBoundary = true;
+        console.warn("[fly] volumes/ip_assignments/certificates carry no per-resource ownership marker — ownership is inferred at the app boundary (#741/#743); only resources under a chant-managed app are reported owned");
+    };
+    for (const app of appsToQuery) {
+        // One machine list per app: it drives both the machine verdicts and the
+        // app-boundary decision (an app is chant-managed when any live machine is).
+        const machines = (await listMachines(ctx, app, http, signal)).filter((m) => !TERMINAL_STATES.has(m.state));
+        const appManaged = machines.some((m) => isChantOwned(m.config?.metadata));
+        // App resource. No per-resource marker; the app-boundary evidence is its own
+        // chant-owned machines. Absent that, ownership is left unset (unknown), so
+        // the change set never proposes deleting an app it can't prove is chant's.
+        const appRes = await http("GET", `${ctx.base}/v1/apps/${encodeURIComponent(app)}`, undefined, undefined, signal);
+        if (appRes.status === 200) {
+            const ownership = appManaged ? "owned" : undefined;
+            if (owned && ownership !== "owned") {
+                withheld(appEntityByName.get(app), "app has no chant-owned machine to prove ownership and --owned was requested");
+            }
+            else {
+                const entityName = appEntityByName.get(app) ?? app;
+                result[entityName] = {
+                    type: typeOf(entityName, TYPE.app),
+                    physicalId: app,
+                    status: "deployed",
+                    ownership,
+                    attributes: { app },
+                };
+            }
+        }
+        // Machines: precise per-marker verdict.
+        for (const m of machines) {
+            const isOwned = isChantOwned(m.config?.metadata);
+            if (owned && !isOwned) {
+                // Withheld by the owned filter — live and foreign, which is not absent.
+                withheld(machineEntity.get(`${app} ${m.name}`), "live machine carries no chant ownership marker and --owned was requested");
+                continue;
+            }
+            const entityName = machineEntity.get(`${app} ${m.name}`) ?? m.name;
+            result[entityName] = {
+                type: typeOf(entityName, TYPE.machine),
+                physicalId: m.id,
+                status: m.state,
+                ownership: isOwned ? "owned" : "foreign",
+                // Marker identity (#1222): machines are the one fly type carrying the
+                // metadata channel, so only they surface stack/env. Apps and the
+                // boundary types (volumes/ips/certs) get their verdict inferred at the
+                // app boundary and carry no marker of their own — absent, not guessed.
+                marker: readOwnership(m.config?.metadata, FLY_METADATA_OWNERSHIP_KEYS),
+                // The release the Machine serves (#2736): `digest` is the identity
+                // attribute core's status join compares with the release ledger
+                // (LIVE_IDENTITY_ATTRIBUTES); `release` carries the rest of what its
+                // metadata records. The commit is reported inside `release`, not as
+                // the `gitSha` identity: a rollback serves an earlier commit under the
+                // digest the ledger records again, so only the digest is the join.
+                attributes: pruneUndefined({
+                    app,
+                    machineName: m.name,
+                    instanceId: m.instance_id,
+                    config: m.config,
+                    ...releaseAttributes(m.config?.metadata),
+                }),
+            };
+        }
+        // ── Metadata-less breadth types (#741): app-boundary ownership. ──────────
+        // Under a chant-managed app they are owned; otherwise ownership is unknown
+        // and, under the `owned` filter, they are dropped (with a one-time note).
+        const boundaryOwnership = appManaged ? "owned" : undefined;
+        try {
+            for (const v of await listVolumes(ctx, app, http, signal)) {
+                if (owned && boundaryOwnership !== "owned") {
+                    noteBoundaryInference();
+                    withheld(volumeEntity.get(`${app} ${v.name}`), "volume sits under an app with no chant-owned machine and --owned was requested");
+                    continue;
+                }
+                if (owned)
+                    noteBoundaryInference();
+                const entityName = volumeEntity.get(`${app} ${v.name}`) ?? v.name;
+                result[entityName] = {
+                    type: typeOf(entityName, TYPE.volume),
+                    physicalId: v.id,
+                    status: v.state ?? "present",
+                    ownership: boundaryOwnership,
+                    attributes: pruneUndefined({ app, volumeName: v.name }),
+                };
+            }
+            for (const ip of await listIps(ctx, app, http, signal)) {
+                const family = ipType(ip.shared, ip.ip);
+                if (owned && boundaryOwnership !== "owned") {
+                    noteBoundaryInference();
+                    withheld(ipEntity.get(`${app} ${family}`), "ip sits under an app with no chant-owned machine and --owned was requested");
+                    continue;
+                }
+                if (owned)
+                    noteBoundaryInference();
+                const entityName = ipEntity.get(`${app} ${family}`) ?? `${app}/${family}`;
+                result[entityName] = {
+                    type: typeOf(entityName, TYPE.ip),
+                    physicalId: ip.ip,
+                    status: "present",
+                    ownership: boundaryOwnership,
+                    attributes: pruneUndefined({ app, family, address: ip.ip }),
+                };
+            }
+            for (const c of await listCerts(ctx, app, http, signal)) {
+                if (owned && boundaryOwnership !== "owned") {
+                    noteBoundaryInference();
+                    withheld(certEntity.get(`${app} ${c.hostname}`), "certificate sits under an app with no chant-owned machine and --owned was requested");
+                    continue;
+                }
+                if (owned)
+                    noteBoundaryInference();
+                const entityName = certEntity.get(`${app} ${c.hostname}`) ?? c.hostname;
+                result[entityName] = {
+                    type: typeOf(entityName, TYPE.cert),
+                    physicalId: c.hostname,
+                    status: "present",
+                    ownership: boundaryOwnership,
+                    attributes: pruneUndefined({ app, hostname: c.hostname }),
+                };
+            }
+        }
+        catch (err) {
+            // A breadth endpoint that is unreachable on this target leaves the diff to
+            // machines + apps rather than failing the whole read — but the volumes,
+            // ips and certs it would have reported were never read, so they are holes
+            // rather than absences (#1089).
+            const detail = `flaps breadth read failed for app "${app}": ${err instanceof Error ? err.message : String(err)}`;
+            for (const entityName of breadthEntitiesOf(app)) {
+                if (result[entityName])
+                    continue; // already read before the failure
+                const type = options.entities.get(entityName)?.entityType;
+                unobserved[entityName] = { ...(type ? { type } : {}), reason: "read-failed", detail };
+            }
+        }
+    }
+    // Present wins: an entity that was read is never also a hole.
+    for (const name of Object.keys(result))
+        delete unobserved[name];
+    return observation(result, unobserved);
+}
+/**
+ * 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 async function flyPlan(options, http = defaultFlyHttp(), signal) {
+    const observed = normalizeObservation(await describeResources(options, http, signal));
+    const observedNow = observed.resources;
+    const declared = new Set(options.entities.keys());
+    const cs = buildChangeSet(options.environment, {
+        declared,
+        observedNow,
+        observedThen: options.observedThen,
+        // Entities flaps could not be asked about stay `unobserved` in the plan
+        // rather than being proposed as creates (#1089).
+        unobserved: observed.unobserved,
+    });
+    // Declared config per entity, for the machine update/noop refinement.
+    const declaredConfig = new Map();
+    try {
+        for (const [entityName, req] of Object.entries(parsePlan(options.buildOutput))) {
+            if (isMachineRequest(req))
+                declaredConfig.set(entityName, req.body.config);
+        }
+    }
+    catch {
+        // no plan to refine against
+    }
+    for (const entry of cs.entries) {
+        if (entry.action !== "noop")
+            continue;
+        const declaredCfg = declaredConfig.get(entry.name);
+        if (declaredCfg === undefined)
+            continue; // not a declared machine
+        const liveCfg = observedNow[entry.name]?.attributes?.config;
+        if (!configEqual(declaredCfg, liveCfg)) {
+            entry.action = "update";
+        }
+    }
+    return { changeSet: cs, rendered: renderChangeSet(cs) };
+}

package/dist/detect.js

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** A single flaps request as the serializer emits it. */
+function isFlapsRequest(v) {
+    if (!isRecord(v))
+        return false;
+    return typeof v.endpoint === "string" && v.endpoint.startsWith("/v1/apps") && "body" in v;
+}
+/** The serializer's whole output: entity name → flaps request. */
+export function isSerializerPlan(v) {
+    if (!isRecord(v))
+        return false;
+    const values = Object.values(v);
+    return values.length > 0 && values.every(isFlapsRequest);
+}
+/** A live or create-body machine: carries a `config` object, or the id+state+region GET shape. */
+export function isMachineObject(v) {
+    if (!isRecord(v))
+        return false;
+    if (isRecord(v.config))
+        return true;
+    return typeof v.id === "string" && typeof v.state === "string" && "region" in v;
+}
+/** An app: a create body (`app_name`) or the `GET /v1/apps/{app}` shape (`name` + machine_count/organization/status). */
+export function isAppObject(v) {
+    if (!isRecord(v))
+        return false;
+    if (typeof v.app_name === "string")
+        return true;
+    return (typeof v.name === "string" &&
+        ("machine_count" in v || "organization" in v || typeof v.status === "string"));
+}
+export function detectTemplate(data) {
+    if (isSerializerPlan(data))
+        return true;
+    if (Array.isArray(data)) {
+        return data.length > 0 && data.some(isMachineObject);
+    }
+    if (isRecord(data)) {
+        if (Array.isArray(data.machines))
+            return true;
+        if (isMachineObject(data))
+            return true;
+        if (isAppObject(data))
+            return true;
+    }
+    return false;
+}

package/dist/export-resources.js

@@ -0,0 +1,81 @@
+/**
+ * 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 { resolveEndpoint, defaultFlyHttp, listMachines, } from "./op/activities/fly-apply.js";
+import { buildExportFromApp } from "./import/live-export.js";
+const DEFAULT_ORG = "personal";
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function orgSlug() {
+    return process.env.FLY_ORG || process.env.FLY_ORG_SLUG || DEFAULT_ORG;
+}
+/** Resolve which apps to export: selector name → FLY_APP_NAME → org listing. */
+async function resolveApps(ctx, selector, http, signal) {
+    if (selector?.name)
+        return [selector.name];
+    if (process.env.FLY_APP_NAME)
+        return [process.env.FLY_APP_NAME];
+    const res = await http("GET", `${ctx.base}/v1/apps?org_slug=${encodeURIComponent(orgSlug())}`, undefined, undefined, signal);
+    if (res.status >= 300)
+        return [];
+    const body = parseJson(res.text);
+    const apps = Array.isArray(body)
+        ? body
+        : body && typeof body === "object" && Array.isArray(body.apps)
+            ? body.apps
+            : [];
+    return apps
+        .map((a) => (a && typeof a === "object" ? a.name : undefined))
+        .filter((n) => typeof n === "string");
+}
+export async function exportResources(options, http = defaultFlyHttp(), signal) {
+    const ctx = { base: resolveEndpoint({}) };
+    const apps = await resolveApps(ctx, options.selector, http, signal);
+    if (apps.length === 0)
+        return { resources: [], parameters: [] };
+    // The app-boundary log fires at most once per call, only under `owned`, when
+    // the marker-less app type is reached (mirrors describe-resources).
+    let loggedBoundary = false;
+    const onBoundaryInference = () => {
+        if (loggedBoundary)
+            return;
+        loggedBoundary = true;
+        console.warn("[fly] apps carry no per-resource ownership marker — ownership is inferred at the app boundary (#741/#743); only apps with a chant-managed machine are exported under --owned");
+    };
+    const resources = [];
+    for (const app of apps) {
+        const appRes = await http("GET", `${ctx.base}/v1/apps/${encodeURIComponent(app)}`, undefined, undefined, signal);
+        const appBody = appRes.status === 200 ? parseJson(appRes.text) : undefined;
+        const appObj = appBody && typeof appBody === "object" && !Array.isArray(appBody)
+            ? appBody
+            : { name: app };
+        const machines = await listMachines(ctx, app, http, signal);
+        const ir = buildExportFromApp(appObj, machines, {
+            verbatim: options.verbatim,
+            selector: options.selector,
+            owned: options.owned,
+            onBoundaryInference,
+        });
+        resources.push(...ir.resources);
+    }
+    return { resources, parameters: [] };
+}

package/dist/generated/index.js

@@ -0,0 +1,44 @@
+// Code generated by chant generate. DO NOT EDIT.
+import { createResource, createProperty } from "./runtime.js";
+export const App = /* @__PURE__ */ createResource("Fly::Machines::App", "fly", { "id": "id", "internal_numeric_id": "internal_numeric_id", "machine_count": "machine_count", "network_cidr": "network_cidr", "organization": "organization", "status": "status", "volume_count": "volume_count" });
+export const Certificate = /* @__PURE__ */ createResource("Fly::Machines::Certificate", "fly", { "acme_requested": "acme_requested", "certificates": "certificates", "configured": "configured", "dns_provider": "dns_provider", "dns_requirements": "dns_requirements", "rate_limited_until": "rate_limited_until", "status": "status", "validation": "validation", "validation_errors": "validation_errors" });
+export const IPAddress = /* @__PURE__ */ createResource("Fly::Machines::IPAddress", "fly", { "created_at": "created_at", "egress": "egress", "ip": "ip", "shared": "shared" });
+export const Machine = /* @__PURE__ */ createResource("Fly::Machines::Machine", "fly", { "checks": "checks", "cordoned": "cordoned", "created_at": "created_at", "events": "events", "host_features": "host_features", "host_status": "host_status", "id": "id", "image_ref": "image_ref", "incomplete_config": "incomplete_config", "instance_id": "instance_id", "lease": "lease", "nonce": "nonce", "private_ip": "private_ip", "state": "state", "updated_at": "updated_at", "version": "version" });
+export const Secret = /* @__PURE__ */ createResource("Fly::Machines::Secret", "fly", { "created_at": "created_at", "digest": "digest", "updated_at": "updated_at" });
+export const Volume = /* @__PURE__ */ createResource("Fly::Machines::Volume", "fly", { "attached_alloc_id": "attached_alloc_id", "attached_machine_id": "attached_machine_id", "block_size": "block_size", "blocks": "blocks", "blocks_avail": "blocks_avail", "blocks_free": "blocks_free", "bytes_total": "bytes_total", "bytes_used": "bytes_used", "created_at": "created_at", "host_features": "host_features", "host_status": "host_status", "id": "id", "required_host_features": "required_host_features", "state": "state", "type": "type", "zone": "zone" });
+export const ContainerConfig = /* @__PURE__ */ createProperty("Fly::Machines::ContainerConfig", "fly");
+export const ContainerDependency = /* @__PURE__ */ createProperty("Fly::Machines::ContainerDependency", "fly");
+export const ContainerHealthcheck = /* @__PURE__ */ createProperty("Fly::Machines::ContainerHealthcheck", "fly");
+export const DNSConfig = /* @__PURE__ */ createProperty("Fly::Machines::DNSConfig", "fly");
+export const DnsForwardRule = /* @__PURE__ */ createProperty("Fly::Machines::DnsForwardRule", "fly");
+export const DnsOption = /* @__PURE__ */ createProperty("Fly::Machines::DnsOption", "fly");
+export const EnvFrom = /* @__PURE__ */ createProperty("Fly::Machines::EnvFrom", "fly");
+export const ExecHealthcheck = /* @__PURE__ */ createProperty("Fly::Machines::ExecHealthcheck", "fly");
+export const File = /* @__PURE__ */ createProperty("Fly::Machines::File", "fly");
+export const HTTPHealthcheck = /* @__PURE__ */ createProperty("Fly::Machines::HTTPHealthcheck", "fly");
+export const HTTPOptions = /* @__PURE__ */ createProperty("Fly::Machines::HTTPOptions", "fly");
+export const HTTPResponseOptions = /* @__PURE__ */ createProperty("Fly::Machines::HTTPResponseOptions", "fly");
+export const MachineCacheDrive = /* @__PURE__ */ createProperty("Fly::Machines::MachineCacheDrive", "fly");
+export const MachineCheck = /* @__PURE__ */ createProperty("Fly::Machines::MachineCheck", "fly");
+export const MachineConfig = /* @__PURE__ */ createProperty("Fly::Machines::MachineConfig", "fly");
+export const MachineGuest = /* @__PURE__ */ createProperty("Fly::Machines::MachineGuest", "fly");
+export const MachineHTTPHeader = /* @__PURE__ */ createProperty("Fly::Machines::MachineHTTPHeader", "fly");
+export const MachineInit = /* @__PURE__ */ createProperty("Fly::Machines::MachineInit", "fly");
+export const MachineMetrics = /* @__PURE__ */ createProperty("Fly::Machines::MachineMetrics", "fly");
+export const MachineMount = /* @__PURE__ */ createProperty("Fly::Machines::MachineMount", "fly");
+export const MachinePort = /* @__PURE__ */ createProperty("Fly::Machines::MachinePort", "fly");
+export const MachineProcess = /* @__PURE__ */ createProperty("Fly::Machines::MachineProcess", "fly");
+export const MachineRestart = /* @__PURE__ */ createProperty("Fly::Machines::MachineRestart", "fly");
+export const MachineRootfs = /* @__PURE__ */ createProperty("Fly::Machines::MachineRootfs", "fly");
+export const MachineSecret = /* @__PURE__ */ createProperty("Fly::Machines::MachineSecret", "fly");
+export const MachineService = /* @__PURE__ */ createProperty("Fly::Machines::MachineService", "fly");
+export const MachineServiceCheck = /* @__PURE__ */ createProperty("Fly::Machines::MachineServiceCheck", "fly");
+export const MachineServiceConcurrency = /* @__PURE__ */ createProperty("Fly::Machines::MachineServiceConcurrency", "fly");
+export const MachineSpot = /* @__PURE__ */ createProperty("Fly::Machines::MachineSpot", "fly");
+export const ProxyProtoOptions = /* @__PURE__ */ createProperty("Fly::Machines::ProxyProtoOptions", "fly");
+export const ReplayCache = /* @__PURE__ */ createProperty("Fly::Machines::ReplayCache", "fly");
+export const Static = /* @__PURE__ */ createProperty("Fly::Machines::Static", "fly");
+export const StopConfig = /* @__PURE__ */ createProperty("Fly::Machines::StopConfig", "fly");
+export const TCPHealthcheck = /* @__PURE__ */ createProperty("Fly::Machines::TCPHealthcheck", "fly");
+export const TLSOptions = /* @__PURE__ */ createProperty("Fly::Machines::TLSOptions", "fly");
+// Re-exports for convenience

package/dist/generated/runtime.js

@@ -0,0 +1,4 @@
+/**
+ * Runtime factory constructors — re-exported from core.
+ */
+export { createResource, createProperty } from "@intentius/chant/runtime";