@molecule/api-code-sandbox-flyio 1.0.18 → 1.2.0

package/dist/egress.js

@@ -46,11 +46,46 @@
  * and that `name` is mandatory — which is why {@link DEFAULT_EGRESS_POLICY_NAME}
  * is always sent.
  *
+ * **THE PORT LIST IS THE WHOLE POLICY — there is no destination, and this was
+ * measured rather than inferred (2026-08-16, live API, throwaway app).** Every
+ * plausible destination field was POSTed and read back: on a RULE,
+ * `ipv6_cidrs` / `ipv4_cidrs` / `cidrs` / `destinations` / `apps` / `app` / `to`
+ * / `dst` are all accepted by the decoder and DROPPED — the stored rule comes
+ * back as `{action, direction, ports}` and nothing else. On the SELECTOR (which
+ * chooses which Machines a policy covers, i.e. the SOURCE, never a destination)
+ * only `all`, `machines` and `metadata` persist; `apps` is the one field the API
+ * answers about, with `400 {"error":"apps array not currently supported in
+ * selectors"}`. So an `allow tcp/5432` rule permits that Machine to reach port
+ * 5432 on EVERY host on the internet, and no arrangement of this object can say
+ * otherwise. {@link describePublicReach} states that in the verdict rather than
+ * leaving an operator to deduce it.
+ *
+ * **The derived private-service ports ARE load-bearing** (the open question this
+ * module and FLY-OPERATOR-SETUP §9 both carried since 2026-08-05). Measured the
+ * same day: with a policy allowing only `udp:53`, a Machine on a custom 6PN
+ * could resolve `molecule-pg-tenant.flycast` and `molecule-api.flycast` but
+ * every TCP connect to them was dropped, and re-applying `tcp:443` re-opened
+ * only 443. Fly's "policies do not affect traffic routed through the Fly Proxy"
+ * is about INGRESS; a Machine's egress TOWARD a Flycast address is filtered like
+ * any other. Dropping a declared service's port would therefore take out every
+ * database connection in the fleet.
+ *
  * @module
  */
 import { shellQuote } from './utilities.js';
 /** Default name of the egress policy this provider owns on each sandbox app. */
 export const DEFAULT_EGRESS_POLICY_NAME = 'molecule-sandbox-egress';
+/**
+ * UDP port name resolution runs on.
+ *
+ * Excluded from {@link describePublicReach}'s "reachable on" list because DNS is
+ * not a TCP channel and is a residual of its own (a resolver forwards queries
+ * upstream on the platform's behalf, which is why DNS tunnelling is tracked
+ * separately in `docs/sandbox-egress-enforcement.md` rather than as an open
+ * port). It is never excluded from {@link unexpectedPolicyPorts}: a policy that
+ * allows DNS this provider did not configure is still drift.
+ */
+const DNS_PORT = 53;
 /**
  * Probe exit status meaning at least one raw connection to a public IP
  * SUCCEEDED. Deliberately not 1, so an interpreter error (which exits 1) can
@@ -175,6 +210,14 @@ export function buildEgressProbeCommand(targets, timeoutMs) {
         `s.on('error',()=>done())}`;
     return `node -e ${shellQuote(script)}`;
 }
+/**
+ * Renders a port list the way an operator reads it back.
+ * @param ports - The ports.
+ * @returns `tcp/443, udp/53`.
+ */
+function formatPorts(ports) {
+    return ports.map((port) => `${port.protocol}/${port.port}`).join(', ');
+}
 /**
  * Describes the policy this provider applied, for the verdict message.
  * @param policyPorts - Allowed ports, or `undefined` when no policy is applied.
@@ -183,8 +226,55 @@ export function buildEgressProbeCommand(targets, timeoutMs) {
 function describePolicy(policyPorts) {
     if (!policyPorts)
         return 'no Fly network policy applied by this provider';
-    const ports = policyPorts.map((port) => `${port.protocol}/${port.port}`).join(', ');
-    return `a Fly network policy allowing egress on ${ports}`;
+    return `a Fly network policy allowing egress on ${formatPorts(policyPorts)}`;
+}
+/**
+ * States, in the verdict itself, what an allowed port actually permits.
+ *
+ * A Fly network policy has no destination (see the module description — measured
+ * against the live API, not inferred), so every allowed port is open to every
+ * host on the internet, not only to the private service it was derived for. That
+ * is the single most consequential thing about this mechanism and it was invisible
+ * everywhere it mattered: the probe attempts one port the policy denies, reports
+ * `filtered`, and an operator reasonably reads that as "nothing gets out".
+ *
+ * Naming it here means the residual is restated on every re-probe (the consumer
+ * re-verifies every 15 minutes) instead of living only in a document.
+ * @param policyPorts - Allowed ports, or `undefined` when no policy is applied.
+ * @returns A sentence naming the public reach, or `''` when there is nothing to
+ *   say (no policy, or nothing but UDP/53 — DNS is a documented residual of its
+ *   own and not a TCP channel).
+ */
+export function describePublicReach(policyPorts) {
+    const reachable = (policyPorts ?? []).filter((port) => port.protocol !== 'udp' || port.port !== DNS_PORT);
+    if (reachable.length === 0)
+        return '';
+    return (`Every allowed port is open to EVERY host, not only to the private service it exists for — ` +
+        `a Fly network policy matches protocol and port with no destination field of any kind — so ` +
+        `code in this app can still reach an arbitrary public host on ${formatPorts(reachable)}. ` +
+        'Route what must be filtered by host through an egress proxy on one of those ports.');
+}
+/**
+ * Finds ports the policy Fly holds allows that this provider never configured.
+ *
+ * The raw-connect probe can only speak for the targets it was handed, so a
+ * policy widened outside this provider — edited by hand to unblock something, or
+ * left behind by an older build — is invisible to it: the probe's own port stays
+ * denied and the verdict stays `filtered` while a port nothing here asked for is
+ * open to the whole internet. Comparing what Fly holds against what this
+ * provider intended is the one check that can catch that, and it is why the
+ * verdict reads the policy back rather than trusting the write.
+ * @param applied - Ports in the policy Fly actually holds, or `undefined` when
+ *   the readback found nothing (in which case there is nothing to compare).
+ * @param intended - Ports this provider configured, or `undefined` when it
+ *   applies no policy.
+ * @returns The applied ports with no counterpart in `intended`, in order.
+ */
+export function unexpectedPolicyPorts(applied, intended) {
+    if (!applied)
+        return [];
+    const wanted = intended ?? [];
+    return applied.filter((port) => !wanted.some((own) => own.protocol === port.protocol && own.port === port.port));
 }
 /**
  * Maps a probe's exit status onto an {@link EgressVerdict}.
@@ -211,6 +301,24 @@ function describePolicy(policyPorts) {
 export function verdictForProbeExit(exitCode, context) {
     const targets = context.targets.map(formatEgressProbeTarget).join(', ');
     const policy = describePolicy(context.policyPorts);
+    const reach = describePublicReach(context.appliedPolicyPorts ?? context.policyPorts);
+    // Drift, and it outranks a blocked probe: the probe attempts the targets it
+    // was handed, so a port widened outside this provider is open with nothing
+    // observing it. `open` is the honest state — something out there permits
+    // traffic this provider never configured.
+    const unexpected = unexpectedPolicyPorts(context.appliedPolicyPorts, context.policyPorts);
+    if (unexpected.length > 0) {
+        return {
+            state: 'open',
+            detail: (`The Fly network policy in force on app "${context.app}" allows ` +
+                `${formatPorts(unexpected)}, which this provider never configured (it applies ` +
+                `${policy}). ${describePublicReach(context.appliedPolicyPorts)}`).trim(),
+            remediation: 'Something outside this provider widened the policy. Inspect it with ' +
+                `\`GET /v1/apps/${context.app}/network_policies\`, remove the rule that does not belong, ` +
+                'and restart the Machines — Fly applies a policy at boot, so an already-running Machine ' +
+                'keeps the wider one until it is recreated.',
+        };
+    }
     if (exitCode === EGRESS_PROBE_EXIT_REACHED) {
         return {
             state: 'open',
@@ -231,7 +339,7 @@ export function verdictForProbeExit(exitCode, context) {
         return {
             state: 'filtered',
             detail: `Raw TCP connects to ${targets} from a Machine in Fly app "${context.app}" ` +
-                `(${policy}) were refused or timed out.`,
+                `(${policy}) were refused or timed out.${reach ? ` ${reach}` : ''}`,
         };
     }
     return {
@@ -267,6 +375,59 @@ function isRecord(value) {
  * @returns The matching policy's id, or `undefined`.
  */
 export function extractPolicyId(response, name) {
+    const entry = findPolicy(response, name);
+    return entry && typeof entry.id === 'string' && entry.id ? entry.id : undefined;
+}
+/**
+ * Reads back the egress ports the policy Fly ACTUALLY holds allows.
+ *
+ * The write is not the observation: this provider POSTs a policy, but what
+ * governs a Machine is whatever Fly has when that Machine boots — which may
+ * differ because a person, another tool or an older build changed it. Reading it
+ * back is what lets {@link unexpectedPolicyPorts} catch a policy wider than the
+ * one this provider configured, so `verifyEgress()` can fail on drift its raw
+ * connects were never going to attempt.
+ *
+ * Parsed as defensively as {@link extractPolicyId}, and for the same reason:
+ * neither Fly document specifies the LIST response shape. The live API answers
+ * with a bare array whose selector key is `netpolSelector` rather than the
+ * `selector` it accepts (verified 2026-08-16), which is exactly why nothing here
+ * depends on any key but `name` and `rules`.
+ * @param response - The raw parsed LIST response.
+ * @param name - The policy name to match.
+ * @returns The allowed egress ports, or `undefined` when no policy of that name
+ *   is present or the shape is unrecognized. `undefined` means "nothing to
+ *   compare", never "nothing is allowed".
+ */
+export function extractPolicyPorts(response, name) {
+    const entry = findPolicy(response, name);
+    if (!entry || !Array.isArray(entry.rules))
+        return undefined;
+    const ports = [];
+    for (const rule of entry.rules) {
+        if (!isRecord(rule) || rule.direction !== 'egress' || !Array.isArray(rule.ports))
+            continue;
+        for (const port of rule.ports) {
+            if (!isRecord(port))
+                continue;
+            const protocol = port.protocol;
+            const value = port.port;
+            if ((protocol !== 'tcp' && protocol !== 'udp') || typeof value !== 'number')
+                continue;
+            if (!ports.some((seen) => seen.protocol === protocol && seen.port === value)) {
+                ports.push({ protocol, port: value });
+            }
+        }
+    }
+    return ports;
+}
+/**
+ * Finds the named policy in a LIST response.
+ * @param response - The raw parsed LIST response.
+ * @param name - The policy name to match.
+ * @returns The matching entry, or `undefined`.
+ */
+function findPolicy(response, name) {
     const list = Array.isArray(response)
         ? response
         : isRecord(response)
@@ -275,9 +436,8 @@ export function extractPolicyId(response, name) {
     if (!Array.isArray(list))
         return undefined;
     for (const entry of list) {
-        if (isRecord(entry) && entry.name === name && typeof entry.id === 'string' && entry.id) {
-            return entry.id;
-        }
+        if (isRecord(entry) && entry.name === name)
+            return entry;
     }
     return undefined;
 }

package/dist/flycast.d.ts

@@ -115,14 +115,25 @@ export declare function parsePrivateServices(raw: string | undefined): FlyPrivat
  * still exactly what they wrote plus the ports their own declarations require,
  * and the applied policy is logged.
  *
- * Whether the addition is even load-bearing is UNVERIFIED: Fly states "Network
- * policies only apply to traffic directly to and from Machines. They do not
- * affect traffic routed through the Fly Proxy"
+ * The addition is load-bearing — VERIFIED 2026-08-16, not inferred. Fly states
+ * "Network policies only apply to traffic directly to and from Machines. They do
+ * not affect traffic routed through the Fly Proxy"
  * (https://fly.io/docs/machines/guides-examples/network-policies/), and Flycast
- * traffic IS routed through Fly Proxy — but Fly says that about ingress and
- * never addresses a Machine's egress toward a Flycast address. An inert entry
- * costs a port on the allow list; a missing one costs every database in the
- * fleet, so the port is added.
+ * traffic IS routed through Fly Proxy, so it was an open question whether these
+ * ports did anything. Measured on a throwaway app with a Flycast address into
+ * its own 6PN: under a policy allowing only `udp:53`, `molecule-pg-tenant.flycast`
+ * and `molecule-api.flycast` both RESOLVED and every TCP connect to them was
+ * dropped; re-applying the policy with `tcp:443` opened 443 and nothing else.
+ * Fly's sentence is about INGRESS — a Machine's egress TOWARD a Flycast address
+ * is filtered like any other. Drop a declared service's port and every database
+ * connection in the fleet goes with it.
+ *
+ * The cost of each derived port, stated plainly because a Fly policy has no
+ * destination field of any kind (also measured — see the `egress.ts` module
+ * description): the port is opened to EVERY host on the internet, not only to
+ * the private service it was derived for. That residual cannot be closed at this
+ * layer; it is named in `verifyEgress()`'s verdict and in
+ * `docs/sandbox-egress-enforcement.md`.
  * @param ports - The operator's configured ports, or `undefined` when no policy
  *   is being applied at all.
  * @param services - The declared private services, or `undefined`.

package/dist/flycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flycast.d.ts","sourceRoot":"","sources":["../src/flycast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEzE;;;;GAIG;AACH,eAAO,MAAM,cAAc,aAAa,CAAA;AAExC;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,kBAAkB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,eAAe,CAAA;AAKnD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,EAAE,GAAG,SAAS,CAqC7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,oBAAoB,EAAE,GAAG,SAAS,EACzC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,SAAS,GACxC,oBAAoB,EAAE,GAAG,SAAS,CAUpC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAI1E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUnF;AA2BD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACvC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,SAAS,GACxC,IAAI,CAwCN"}
+{"version":3,"file":"flycast.d.ts","sourceRoot":"","sources":["../src/flycast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEzE;;;;GAIG;AACH,eAAO,MAAM,cAAc,aAAa,CAAA;AAExC;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,kBAAkB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,eAAe,CAAA;AAKnD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,EAAE,GAAG,SAAS,CAqC7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,oBAAoB,EAAE,GAAG,SAAS,EACzC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,SAAS,GACxC,oBAAoB,EAAE,GAAG,SAAS,CAUpC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAI1E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUnF;AA2BD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACvC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,SAAS,GACxC,IAAI,CAwCN"}

package/dist/flycast.js

@@ -147,14 +147,25 @@ export function parsePrivateServices(raw) {
  * still exactly what they wrote plus the ports their own declarations require,
  * and the applied policy is logged.
  *
- * Whether the addition is even load-bearing is UNVERIFIED: Fly states "Network
- * policies only apply to traffic directly to and from Machines. They do not
- * affect traffic routed through the Fly Proxy"
+ * The addition is load-bearing — VERIFIED 2026-08-16, not inferred. Fly states
+ * "Network policies only apply to traffic directly to and from Machines. They do
+ * not affect traffic routed through the Fly Proxy"
  * (https://fly.io/docs/machines/guides-examples/network-policies/), and Flycast
- * traffic IS routed through Fly Proxy — but Fly says that about ingress and
- * never addresses a Machine's egress toward a Flycast address. An inert entry
- * costs a port on the allow list; a missing one costs every database in the
- * fleet, so the port is added.
+ * traffic IS routed through Fly Proxy, so it was an open question whether these
+ * ports did anything. Measured on a throwaway app with a Flycast address into
+ * its own 6PN: under a policy allowing only `udp:53`, `molecule-pg-tenant.flycast`
+ * and `molecule-api.flycast` both RESOLVED and every TCP connect to them was
+ * dropped; re-applying the policy with `tcp:443` opened 443 and nothing else.
+ * Fly's sentence is about INGRESS — a Machine's egress TOWARD a Flycast address
+ * is filtered like any other. Drop a declared service's port and every database
+ * connection in the fleet goes with it.
+ *
+ * The cost of each derived port, stated plainly because a Fly policy has no
+ * destination field of any kind (also measured — see the `egress.ts` module
+ * description): the port is opened to EVERY host on the internet, not only to
+ * the private service it was derived for. That residual cannot be closed at this
+ * layer; it is named in `verifyEgress()`'s verdict and in
+ * `docs/sandbox-egress-enforcement.md`.
  * @param ports - The operator's configured ports, or `undefined` when no policy
  *   is being applied at all.
  * @param services - The declared private services, or `undefined`.

package/dist/index.d.ts

@@ -281,12 +281,14 @@
  * exist for providers whose templates are host-local; object storage is already
  * the shared store, so there is nothing to publish or fetch.
  *
- * **`exportFiles`/`importFiles` are NOT implemented.** The core says a provider
- * with no bulk transfer should leave them unimplemented rather than emulate one,
- * and Fly's only channel is the `exec` endpoint's JSON response — a file-by-file
- * or base64 emulation would look supported and take hours. The template path
- * moves bulk data without them precisely because it never routes the bytes
- * through the control plane.
+ * **`importFiles` IS implemented; `exportFiles` is not.** Import takes the same
+ * route the template restore does — a presigned object-store URL the Machine
+ * pulls itself, falling back to chunked base64 over `exec` when no store is
+ * configured — so an app tree can be delivered into a fresh Machine. There is no
+ * inverse: Fly's only read channel is the `exec` endpoint's JSON response, and a
+ * base64 emulation of a whole-tree export would look supported and route every
+ * byte through the control plane. Pair a Fly destination with a source that CAN
+ * export (the core's rooting contract makes them interchangeable).
  *
  * **Sandbox ids are composite: `"<app>:<machineId>"`.** A Fly Machine id is only
  * unique within its app and every endpoint is `/v1/apps/{app}/machines/{id}`, so

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwUG;AAEH,cAAc,UAAU,CAAA;AACxB,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAMjE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,eAUrB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0UG;AAEH,cAAc,UAAU,CAAA;AACxB,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAMjE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,eAUrB,CAAA"}

package/dist/index.js

@@ -281,12 +281,14 @@
  * exist for providers whose templates are host-local; object storage is already
  * the shared store, so there is nothing to publish or fetch.
  *
- * **`exportFiles`/`importFiles` are NOT implemented.** The core says a provider
- * with no bulk transfer should leave them unimplemented rather than emulate one,
- * and Fly's only channel is the `exec` endpoint's JSON response — a file-by-file
- * or base64 emulation would look supported and take hours. The template path
- * moves bulk data without them precisely because it never routes the bytes
- * through the control plane.
+ * **`importFiles` IS implemented; `exportFiles` is not.** Import takes the same
+ * route the template restore does — a presigned object-store URL the Machine
+ * pulls itself, falling back to chunked base64 over `exec` when no store is
+ * configured — so an app tree can be delivered into a fresh Machine. There is no
+ * inverse: Fly's only read channel is the `exec` endpoint's JSON response, and a
+ * base64 emulation of a whole-tree export would look supported and route every
+ * byte through the control plane. Pair a Fly destination with a source that CAN
+ * export (the core's rooting contract makes them interchangeable).
  *
  * **Sandbox ids are composite: `"<app>:<machineId>"`.** A Fly Machine id is only
  * unique within its app and every endpoint is `/v1/apps/{app}/machines/{id}`, so

package/dist/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAUV,eAAe,EAEhB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,YAAY,EAAgC,MAAM,UAAU,CAAA;AAsBrE,OAAO,EAAmD,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAEhG,OAAO,KAAK,EAEV,WAAW,EAUZ,MAAM,YAAY,CAAA;AAw6DnB;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,MAAM,CAAC,EAAE,WAAW,EACpB,MAAM,CAAC,EAAE,YAAY,EACrB,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,GACzB,eAAe,CAEjB"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAWV,eAAe,EAGhB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,YAAY,EAAgC,MAAM,UAAU,CAAA;AAwBrE,OAAO,EAAmD,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAEhG,OAAO,KAAK,EAIV,WAAW,EAUZ,MAAM,YAAY,CAAA;AA0tEnB;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,MAAM,CAAC,EAAE,WAAW,EACpB,MAAM,CAAC,EAAE,YAAY,EACrB,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,GACzB,eAAe,CAEjB"}