@volter/twin-fly 0.1.0

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+export { handleFlyTwinRequest, flyTwinSnapshot, FLY_API_HOST, FLY_INTERNAL_API_HOST, FLY_RESOURCE_TYPES } from './fly-twin.js';
+export type { FlyRequest, FlyResponse } from './fly-twin.js';
+export { createFlyTwinFetch, createFlyTwinServer } from './fly-server.js';
+export type { FlyTwinFetchOptions } from './fly-server.js';
+export { resolveFlyRuntime } from './fly-runtime-choice.js';
+export type { FlyServerRuntimeChoice, FlyLocalExecutionOptions } from './fly-runtime-choice.js';
+export { containerSpecOf, FLY_MACHINE_STATES, flyRuntimeEnv, imageRefOf, machinePrivateIp, newInstanceId, newMachineId, newMachineName, newVolumeId, VIRTUAL_FLY_RUNTIME, } from './fly-machines.js';
+export type { FlyContainerRuntime, FlyContainerSpec, FlyExecResult, FlyMachineEvent, FlyMachineState, FlyPortSpec, } from './fly-machines.js';
+export { liveFlyExecute, mapApp, mapMachine, mapVolume, pullFlyApps, pullFlyMachines, pullFlyVolumes, syncFlyFromReal, flyExecuteOver, syncFlyFromRemote, performFlyAction, } from './fly-connector.js';
+export type { FlyExecute, LiveFlyOptions } from './fly-connector.js';
+export { FLY_BUDGET_CEILING, FLY_BUDGET_MAX_RETRY_AFTER_S, FLY_BUDGET_WINDOW_MS, FLY_CALL_WEIGHTS, FLY_RATE_BUDGET, FlyBudget, FlyBudgetError, flyBudgetPath, flyCallWeight, } from './fly-budget.js';
+export type { FlyBudgetErrorKind, FlyBudgetOptions, FlyBudgetReservation, FlyBudgetSnapshot } from './fly-budget.js';
+import { type TwinPack } from '@volter/world-core';
+export declare const pack: TwinPack;

package/dist/src/index.js

@@ -0,0 +1,117 @@
+// @volter/twin-fly — the Fly.io MACHINES API twin (api.machines.dev/v1), built on the shared
+// @volter/world-core kernel. The first REAL-EXECUTION-PLANE compute twin in the catalog: the control
+// plane (apps / machines / volumes / secrets, machine lifecycle states + events, leases, wait)
+// is a faithful, stateful local surface over kernel event-sourced state — and when a machine is
+// created or started the twin ACTUALLY runs `config.image` as a real local Docker container
+// through the injected `FlyContainerRuntime` seam (fly-docker.ts). The supabase doctrine at the
+// compute layer: twin the control plane, run the real engine. Offline by default: the pure-ledger
+// VIRTUAL runtime means every verify, test and gate runs with no Docker daemon anywhere.
+//
+// Bearer auth is faked-but-enforced. No real Fly is ever contacted (the connector's injected
+// executor is the one live boundary, budget-guarded).
+//
+// (Conformance tooling lives in @volter/world-tooling, a dev dependency — not shipped here, and
+// `./fly-conformance.ts` is NOT re-exported: cli.ts imports it lazily.)
+export { handleFlyTwinRequest, flyTwinSnapshot, FLY_API_HOST, FLY_INTERNAL_API_HOST, FLY_RESOURCE_TYPES } from "./fly-twin.js";
+export { createFlyTwinFetch, createFlyTwinServer } from "./fly-server.js";
+export { resolveFlyRuntime } from "./fly-runtime-choice.js";
+export { containerSpecOf, FLY_MACHINE_STATES, flyRuntimeEnv, imageRefOf, machinePrivateIp, newInstanceId, newMachineId, newMachineName, newVolumeId, VIRTUAL_FLY_RUNTIME, } from "./fly-machines.js";
+// NB: `./fly-docker.ts` (the real execution plane) is deliberately NOT re-exported here: the
+// host boundary resolves it lazily (`resolveFlyRuntime('docker')` in fly-runtime-choice.ts, dev plane), so `node:child_process` and the
+// docker CLI wrapper never enter the runtime graph of a consumer that stays virtual. Import it
+// by direct path if you genuinely want the docker runtime in-process.
+export { liveFlyExecute, mapApp, mapMachine, mapVolume, pullFlyApps, pullFlyMachines, pullFlyVolumes, syncFlyFromReal, flyExecuteOver, syncFlyFromRemote, performFlyAction, } from "./fly-connector.js";
+// The client-side rate budget — the fail-closed backstop `liveFlyExecute` routes every live
+// request through. Exported so an operator can inspect spend; there is deliberately no export
+// that disables the guard.
+export { FLY_BUDGET_CEILING, FLY_BUDGET_MAX_RETRY_AFTER_S, FLY_BUDGET_WINDOW_MS, FLY_CALL_WEIGHTS, FLY_RATE_BUDGET, FlyBudget, FlyBudgetError, flyBudgetPath, flyCallWeight, } from "./fly-budget.js";
+// Registry descriptor: the pack self-describes so tooling can discover it.
+import { registerPack, referenceField } from '@volter/world-core';
+import { FLY_RATE_BUDGET as RATE_BUDGET } from "./fly-budget.js";
+import { performFlyAction as perform, syncFlyFromRemote as refresh } from "./fly-connector.js";
+export const pack = {
+    vendor: 'fly',
+    // PROTOCOL 2 (docs/contributing/architecture.md#protocol-2-the-pack-is-a-plugin): the pack is a plugin — its wire, its tree, and its half of the real
+    // state system: perform one entry against Fly, refresh the root from it. Moved 2026-09-08. A performed
+    // machine-create provisions real, billable compute: the head performs only when an operator bound it to
+    // a real state system.
+    protocol: '2',
+    refresh: { every: '5m', onDemand: { atMost: '30s' } }, // the Machines API has no webhooks: polled, or on demand
+    stateSystem: { perform, refresh },
+    // the round trip: an app (its name is Fly's id — the first write may answer 422 name-taken on a branch that
+    // already holds it, and the round trip reads the LAST write's answer), then a volume in it
+    roundTrip: [
+        { method: 'POST', path: '/v1/apps', body: { app_name: 'round-trip', org_slug: 'personal' }, headers: { authorization: 'Bearer round-trip' } },
+        { method: 'POST', path: '/v1/apps/round-trip/volumes', body: { name: 'data', region: 'sjc', size_gb: 1 }, headers: { authorization: 'Bearer round-trip' } },
+    ],
+    // rule 5: a machine, a volume and a secret name their app; a machine's mount names its volume, and a volume
+    // names the machine it is attached to. When the head adopts Fly's id for any of them, the kernel resolves the
+    // referencing side first. The reference trip is a machine in the round trip's app (a mount would bind the one
+    // volume to the first machine — Fly attaches a volume once — so the trip that repeats names only its app).
+    referenceTrip: { method: 'POST', path: '/v1/apps/{{id}}/machines', body: { region: 'sjc', config: { image: 'nginx:1.27' } }, headers: { authorization: 'Bearer round-trip' } },
+    references: [
+        referenceField('machine', 'app_name', 'app'),
+        referenceField('volume', 'app_name', 'app'),
+        referenceField('secret', 'app_name', 'app'),
+        {
+            type: 'machine', to: 'volume',
+            key: (f) => { const mounts = f.config?.mounts; const v = mounts?.[0]?.volume; return typeof v === 'string' && v ? v : undefined; },
+            adopt: (f, vendorId) => { const config = (f.config ?? {}); const mounts = [...(config.mounts ?? [])]; if (mounts[0])
+                mounts[0] = { ...mounts[0], volume: vendorId }; return { config: { ...config, mounts } }; },
+        },
+        referenceField('volume', 'attached_machine_id', 'machine'),
+    ],
+    parityOrigin: 'http://twin',
+    shapeParity: 'held',
+    // the execution plane: real local Docker containers live outside the world store, by declaration
+    engine: { module: 'fly-docker', note: 'real local Docker containers: a started machine runs config.image; the tree references the container by ref' },
+    // The SAME object fly-budget.ts declares at module load — one source of truth, so registering
+    // the pack and importing the connector can never arm two different ceilings.
+    rateBudget: RATE_BUDGET,
+    transport: 'rest',
+    archetype: 'engine-control',
+    bin: 'world-fly',
+    resources: ['app', 'machine', 'volume', 'secret'],
+    specSource: "Fly.io Machines API — first-party OpenAPI (docs.machines.dev/swagger/doc.json, 'Machines API 1.0') "
+        + 'cross-checked against superfly/fly-go (flyctl\'s own client); fly.io/docs/machines/api for hosts, '
+        + 'response codes and rate limits',
+    description: 'Fly.io Machines API twin — apps/machines/volumes/secrets CRUD, the machine lifecycle '
+        + '(states + ledgered events, wait, leases, metadata, exec), connector pull. The execution '
+        + 'plane is REAL local Docker via the injected FlyContainerRuntime seam: created/started '
+        + 'machines genuinely run config.image as local containers (virtual pure-ledger runtime by '
+        + 'default, so everything works offline).',
+    // Adoption + interception, moved off the central maps unchanged (descriptor-first back-migration, adding-a-twin.md §3,
+    // 2026-08-31).
+    //
+    // Fly publishes NO first-party npm client (flyctl embeds the Go client superfly/fly-go; the
+    // docs' contract is "point FLY_API_HOSTNAME at the base URL and speak REST"), so the canonical
+    // integration is a hand-written fetch wrapper and the credential env var is the PRIMARY scan
+    // signal: FLY_API_TOKEN — the exact var Fly's own docs export next to FLY_API_HOSTNAME — stems
+    // to `fly` under _API_TOKEN. FLY_API_HOSTNAME itself deliberately does NOT stem: _HOSTNAME is
+    // no credential/endpoint suffix, so it never reaches the lookup. `fly-admin` is the one real
+    // npm client of the modeled surface worth claiming (Supabase's maintained TS client for
+    // api.machines.dev; its base URL is a constructor option, so pointing it at the twin is
+    // configuration). No scope to claim — Fly owns no npm scope for API clients.
+    adoption: {
+        // No official Python SDK - flyctl and `fly-admin` (npm) are the vendor's clients. The community
+        // `fly-python-sdk` is a single-author wrapper with negligible adoption, deliberately unclaimed.
+        pypi: [],
+        sdks: ['fly-admin'], envStems: ['FLY'],
+    },
+    // TWO base hosts, both from Fly's own docs (fly.io/docs/machines/api/working-with-machines-api
+    // "API addresses"):
+    //   • api.machines.dev — the public base URL every out-of-mesh client uses (flyctl's flaps
+    //     transport, fly-admin, plain fetch with FLY_API_HOSTNAME).
+    //   • _api.internal    — the internal base URL (port 4280) reachable only inside a Fly
+    //     WireGuard mesh; claimed so code written for in-mesh deployment redirects to the twin
+    //     instead of failing DNS on a laptop.
+    // fly.io itself (the dashboard/website) and api.fly.io (the legacy GraphQL API this pack does
+    // not model) are deliberately unclaimed: strict egress should fail closed on a surface the twin
+    // does not serve rather than let a half-modeled flow through.
+    hosts: [{ host: 'api.machines.dev' }, { host: '_api.internal' }],
+    // Machines API clients hit https://api.machines.dev/v1/... (or http://_api.internal:4280 from
+    // inside a Fly private network); the dev proxy forwards the /v1/ prefix to the twin.
+    browserRouting: { apiPathPrefix: '/v1/', loaderHost: 'https://api.machines.dev' },
+};
+// registered at import: the kernel learns the pack's state system and its references (protocol 2)
+registerPack(pack);

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@volter/twin-fly",
+  "version": "0.1.0",
+  "description": "Local Fly.io Machines API twin (api.machines.dev v1: apps/machines/volumes/secrets CRUD, machine lifecycle states+events, leases, wait) whose execution plane is REAL local Docker — control plane twinned, containers genuinely run. Built on @volter/world-core.",
+  "author": "Volter (https://github.com/volter-ai)",
+  "license": "Apache-2.0",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    "!**/*.test.ts",
+    "!**/*.test.tsx",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/volter-ai/twin.git",
+    "directory": "packages/twin/fly"
+  },
+  "homepage": "https://github.com/volter-ai/twin/tree/main/packages/twin/fly#readme",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "bin": {
+    "world-fly": "dist/src/cli.js"
+  },
+  "scripts": {
+    "test": "bun test src/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "node ../../../scripts/publish/build.mjs",
+    "prepack": "node ../../../scripts/publish/prepare-publish.mjs prepack",
+    "postpack": "node ../../../scripts/publish/prepare-publish.mjs postpack"
+  },
+  "peerDependencies": {
+    "@volter/world-core": "2.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.20",
+    "@types/node": "^24.0.0",
+    "@volter/world-core": "2.0.0",
+    "@volter/world-tooling": "0.1.0",
+    "typescript": "^5.9.0"
+  },
+  "engines": {
+    "node": ">=22.3"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// world-fly CLI: serve the Machines API twin, or run conformance. There is no `mirror` command —
+// Fly is an API-first vendor with no product UI to mirror (see README `### No UI mirror`).
+//
+// The EXECUTION PLANE is explicit: `serve` defaults to the pure-ledger VIRTUAL runtime (offline,
+// nothing runs); `serve --local-execution` runs real local Machines and FAILS LOUDLY if local
+// execution is unavailable — never a silent downgrade a caller could mistake for real machines.
+import { hasFlag, optionValue } from '@volter/world-core/args';
+import { createFlyTwinServer } from './fly-server.ts';
+import { resolveFlyRuntime } from './fly-runtime-choice.ts';
+
+const [cmd, ...rest] = process.argv.slice(2);
+
+/** A malformed port must FAIL, not silently become an ephemeral one (the smtp `--port 1O25`
+ *  lesson). `0` is accepted and means "ephemeral". */
+function portOption(flag: string): number | undefined {
+  const raw = optionValue(rest, flag);
+  if (raw === undefined || raw === '') return undefined;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+    process.stderr.write(`world-fly: ${flag} must be an integer 0-65535 (got ${JSON.stringify(raw)})\n`);
+    process.exit(2);
+  }
+  return value === 0 ? undefined : value;
+}
+
+/** A non-negative whole number of MiB, or undefined when the flag is absent. Malformed FAILS
+ *  (the `--port 1O25` lesson) — a World that asked for a different admission floor and silently
+ *  got the default would be told nothing. */
+function reserveOption(flag: string): number | undefined {
+  const raw = optionValue(rest, flag);
+  if (raw === undefined || raw === '') return undefined;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    process.stderr.write(`world-fly: ${flag} must be a non-negative integer number of MiB (got ${JSON.stringify(raw)})\n`);
+    process.exit(2);
+  }
+  return value;
+}
+
+const port = portOption('--port');
+const root = optionValue(rest, '--root') || undefined;
+const readOnly = hasFlag(rest, '--read-only');
+const localExecution = hasFlag(rest, '--local-execution') || hasFlag(rest, '--docker');
+// The writable-storage RESERVE admission keeps free beyond a machine's own need — a mechanism
+// value the World configures (default 2048 MiB), never a constant compiled into the runtime.
+const storageReserveMiB = reserveOption('--storage-reserve-mib');
+
+if (cmd === 'serve') {
+  const server = await createFlyTwinServer({
+    cleanupOwnedOnStart: process.env.VOLTER_WORLD_NAME !== undefined,
+    readOnly,
+    runtime: await resolveFlyRuntime(localExecution ? 'docker' : 'virtual', root, {
+      ...(storageReserveMiB !== undefined ? { storageReserveMiB } : {}),
+    }),
+    ...(root ? { root } : {}),
+    ...(port ? { port } : {}),
+  });
+  process.stdout.write(`machine provider${readOnly ? ' [read-only]' : ''} ready on http://127.0.0.1:${server.port}\n`);
+  const signal = await new Promise<'SIGINT' | 'SIGTERM'>((resolveSignal) => {
+    process.once('SIGINT', () => resolveSignal('SIGINT'));
+    process.once('SIGTERM', () => resolveSignal('SIGTERM'));
+  });
+  try {
+    await server.stop();
+  } catch (error) {
+    process.stderr.write(`machine provider: ${signal} cleanup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  }
+} else if (cmd === 'conformance') {
+  const { checkFlyConformance } = await import('./fly-conformance.ts'); // lazy — dev-only
+  const report = await checkFlyConformance();
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (!report.ok) process.exitCode = 1;
+} else {
+  process.stdout.write('Usage: world-fly serve|conformance [--port N] [--root DIR] [--read-only] [--local-execution] [--storage-reserve-mib N]\n');
+}

package/src/fly-budget.ts

@@ -0,0 +1,121 @@
+// Fly.io's CLIENT-SIDE RATE BUDGET — the pack's DECLARATION (the numbers) plus the vendor-bound
+// bindings `liveFlyExecute` (fly-connector.ts) routes every live Machines API call through. The
+// MECHANISM — the durable token-keyed ledger, the rolling window, reserve-under-lock, the
+// `Retry-After`/429 cooldown, fail-CLOSED on a corrupt ledger — lives ONCE in the vendor-agnostic
+// kernel (`@volter/world-core` → rateBudget.ts). This module is modeled on supabase-budget.ts (the
+// same shape: the pack builds its own HTTP executor, so the guard sits inside the one function
+// that issues a live request).
+//
+// ── WHAT FLY ACTUALLY PUBLISHES (live-fetched 2026-08-20,
+//    fly.io/docs/machines/api/working-with-machines-api "Rate Limits") ───────────────────────
+// "Machines API rate limits apply per-action, per-machine and are scoped per identifier
+//  (Machine ID or App ID). The limit is 1 request, per second, per action — with a short-term
+//  burst limit up to 3 req/s, per action. This applies to all actions except Get Machine which
+//  is 5 req/s, with a short-term burst limit up to 10 req/s. Additionally, app deletions are
+//  limited to 100 per minute."
+//
+// Those are PER-ACTION PER-RESOURCE limits; Fly publishes NO account-wide scalar, and this
+// ledger is account-wide (one ledger per token) — a shape mismatch this declaration resolves in
+// the tight direction: the ceiling is pinned to the kernel's conservative fallback
+// (DEFAULT_RATE_BUDGET: 60 weighted units / 60s at weight 2 = 30 calls/minute — a rate the
+// vendor's own per-action allowance of 60/min/action trivially admits), rather than multiplying
+// per-action numbers into an invented account-wide figure. Machine CREATION is priced heavier
+// (weight 3) than reads/actions — creation provisions real billable infrastructure and is the
+// call a runaway loop repeats; pricing it at 3 means a creation-only loop is stopped after 20
+// creates in a minute, tighter than Fly's own 60/min-per-app. Same-burst-as-fallback, so no
+// VENDOR_BURST_ANCHOR entry is needed (the anchor binds only out-bursting declarations).
+import {
+  declareRateBudget,
+  rateBudgetPath,
+  rateBudgetWeight,
+  RateBudget,
+  type RateBudgetDeclaration,
+  type RateBudgetOptions,
+  type RateBudgetReservation,
+  type RateBudgetSnapshot,
+} from '@volter/world-core';
+
+const VENDOR = 'fly';
+
+/** Rolling window, in ms (the kernel fallback's window — a window may never be shorter). */
+export const FLY_BUDGET_WINDOW_MS = 60_000;
+
+/** Weighted units allowed inside one window. Pinned to the kernel fallback — see the header. */
+export const FLY_BUDGET_CEILING = 60;
+
+/** Seconds. A `Retry-After` above this means the credential is throttled hard — fail loudly. */
+export const FLY_BUDGET_MAX_RETRY_AFTER_S = 300;
+
+/** Per-call cost. `create` is machine/volume/app creation (billable provisioning); `other` is
+ *  everything else (reads and lifecycle actions). */
+export const FLY_CALL_WEIGHTS = {
+  create: 3,
+  other: 2,
+} as const;
+
+/** THE PACK'S DECLARATION — pure data, the only Fly-specific thing in the whole budget.
+ *  Calls are priced by a `METHOD /path` key (see flyCallWeight); the create rule matches the
+ *  three provisioning POSTs (apps, machines, volumes collection endpoints). */
+export const FLY_RATE_BUDGET: RateBudgetDeclaration = {
+  windowMs: FLY_BUDGET_WINDOW_MS,
+  ceiling: FLY_BUDGET_CEILING,
+  defaultWeight: FLY_CALL_WEIGHTS.other,
+  maxRetryAfterSeconds: FLY_BUDGET_MAX_RETRY_AFTER_S,
+  // First-match-wins. POST on a collection endpoint (…/apps, …/machines, …/volumes) is a
+  // billable CREATE; the $ anchors keep one-resource POSTs (…/machines/{id}, lifecycle actions)
+  // at the default price.
+  rules: [
+    { match: '^POST /v1/apps$', weight: FLY_CALL_WEIGHTS.create },
+    { match: '^POST /v1/apps/[^/]+/machines$', weight: FLY_CALL_WEIGHTS.create },
+    { match: '^POST /v1/apps/[^/]+/volumes$', weight: FLY_CALL_WEIGHTS.create },
+  ],
+  reason:
+    'Fly publishes PER-ACTION, PER-RESOURCE Machines API limits (fly.io/docs/machines/api/working-with-machines-api, ' +
+    'live-fetched 2026-08-20): 1 req/s per action per machine with short bursts to 3 req/s; Get Machine 5 req/s ' +
+    'bursting to 10; app deletions 100/min. There is NO published account-wide scalar, and this ledger is ' +
+    'account-wide (per token), so the ceiling is pinned to the kernel fallback (60 units / 60s at weight 2 = ' +
+    '30 calls/min — a rate the per-action allowance of 60/min/action trivially admits) rather than multiplying ' +
+    'per-action numbers into an invented account figure. Creation POSTs (apps/machines/volumes) cost 3: they ' +
+    'provision real billable infrastructure, so a runaway create loop is refused after 20/min, tighter than ' +
+    "Fly's own 60 creates/min/app. Window and burst equal the fallback's, so nothing here is more permissive " +
+    'than an undeclared vendor already gets.',
+};
+
+// Declared at module load, so merely importing this module (which fly-connector.ts does) is
+// enough to arm the real ceiling.
+declareRateBudget(VENDOR, FLY_RATE_BUDGET);
+
+/** Price one Machines API call by `METHOD /path` (query string stripped by the caller). */
+export function flyCallWeight(method: string, path: string): number {
+  return rateBudgetWeight(VENDOR, `${method.toUpperCase()} ${path}`);
+}
+
+/** Where Fly's ledger lives. Token-keyed and cwd-independent by default (Fly limits per
+ *  identifier under one account/token, so a cwd-scoped ledger would hand the same token a fresh
+ *  allowance in every checkout, worktree and CI matrix leg); pass `root` for world-scoped
+ *  accounting. */
+export function flyBudgetPath(opts: { root?: string; token?: string } | string = {}): string {
+  const o = typeof opts === 'string' ? { root: opts } : opts;
+  // VENDOR spread LAST: a loosely-typed `{ vendor: 'other', … }` slipping through must not
+  // redirect this pack's ledger to another vendor's file.
+  return rateBudgetPath({ ...o, vendor: VENDOR });
+}
+
+/** Construction options for Fly's budget. The vendor is fixed; everything else may only TIGHTEN. */
+export type FlyBudgetOptions = Omit<RateBudgetOptions, 'vendor'>;
+
+/**
+ * Fly's budget — the shared kernel guard bound to this vendor's declaration. A real subclass,
+ * not an alias, so `budget instanceof FlyBudget` means "a budget that accounts against this
+ * vendor's ledger under this vendor's ceiling".
+ */
+export class FlyBudget extends RateBudget {
+  constructor(opts: FlyBudgetOptions = {}) {
+    super({ ...opts, vendor: VENDOR });
+  }
+}
+
+export type { RateBudgetErrorKind as FlyBudgetErrorKind } from '@volter/world-core';
+export { RateBudgetError as FlyBudgetError } from '@volter/world-core';
+export type FlyBudgetReservation = RateBudgetReservation;
+export type FlyBudgetSnapshot = RateBudgetSnapshot;