import { n as FrameSignature } from "./frame-report-DNxDAb1w.js";

//#region src/vite/discover.d.ts
/**
* The listening TCP ports in `/proc/net/tcp` (and `tcp6`) format.
*
* Linux-only and dependency-free ON PURPOSE: `lsof` and `ss` are routinely
* absent from a slim container, and this has to work in the container a
* vibe-coding service actually ships, not in a developer's laptop.
*/
declare function parseProcNetTcp(text: string): number[];
interface DiscoverDeps {
  /** Reads a proc file; returns null when it is not there (macOS, Windows). */
  read(path: string): string | null;
}
/**
* Ports worth asking, in the order worth asking them.
*
* Observed first — those are facts. The usual suspects after, because a
* container that hides `/proc` should still find a vite server on 5173.
*/
declare function listeningPorts(deps?: Partial<DiscoverDeps>): Promise<number[]>;
//#endregion
//#region src/vite/frame-endpoint.d.ts
interface FrameHost {
  config?: {
    root?: string;
  };
  middlewares: {
    use(path: string, handler: (req: FrameReq, res: FrameRes) => void): void;
  };
  /**
  * Vite's HMR channel, which has moved twice. `ws` on v5, `hot` on v6+, and
  * since the Environment API the one that actually reaches the BROWSER is
  * `environments.client.hot` — on v8 the top-level `hot` still exists and
  * still accepts `send()` without error, it simply arrives nowhere. Every
  * candidate is used, because a silent no-op is the worst of the three.
  */
  ws?: FrameChannel;
  hot?: FrameChannel;
  environments?: {
    client?: {
      hot?: FrameChannel;
    };
  };
}
interface FrameChannel {
  send(payload: {
    type: "custom";
    event: string;
    data?: unknown;
  }): void;
  on(event: string, cb: (data: unknown) => void): void;
}
interface FrameRes {
  statusCode: number;
  setHeader(name: string, value: string): void;
  end(body?: string): void;
}
/** Connect strips the mount path off `url`; `originalUrl` keeps the query. */
interface FrameReq {
  url?: string;
  originalUrl?: string;
}
interface FrameEndpointOptions {
  /** Overridden in tests; defaults to the real clock. */
  now?: () => number;
  timeoutMs?: number;
  /**
  * Remembered frames, by label. Lives in the dev server's MEMORY on purpose:
  * a baseline is only valid for the browser and the window that made it, so it
  * should die with the server rather than linger in the project as a file
  * nobody asked for.
  */
  store?: Map<string, FrameSignature>;
}
declare function serveFrameEndpoints(host: FrameHost, version: string, opts?: FrameEndpointOptions): void;
//#endregion
//#region src/vite/options.d.ts
/**
* A plugin option the plugin does not know is a hard error, like every other
* key this engine reads.
*
* Scene props have had `UNKNOWN_PROP` — "Valid props: […]" — since the first
* milestone. A vite plugin's options had nothing: `incantoScenes({
* strictBehavior: true })` type-checked green, built green and did NOTHING,
* because the scaffolded `tsconfig.json` never pointed the compiler at
* `vite.config.ts` in the first place.
*
* That `include` is fixed too, but it cannot be the whole answer. TypeScript's
* excess-property check only fires on a FRESH object literal — hoist the
* options into a `const` and it passes again — and a `vite.config.js` is never
* type-checked at all. This is the half that holds either way.
*/
declare function onlyKnownOptions(plugin: string, opts: object, known: readonly string[]): void;
//#endregion
//#region src/vite/static-inspect.d.ts
interface StaticInspectHost extends FrameHost {
  /** Handle `/__incanto/pull` and `/__incanto/push`; returns false if not ours. */
  handleInspect(req: FrameReq, res: FrameRes): boolean;
  /** The `<script>` to inject ahead of the game, as page source. */
  clientScript(): string;
}
/**
* Build a `FrameHost` whose channel is a long poll.
*
* `use(path, handler)` records middleware the caller dispatches; `hot` is a
* channel that queues outgoing requests and delivers the page's replies.
*/
declare function createStaticInspectHost(root: string): StaticInspectHost;
//#endregion
//#region src/vite/trim.d.ts
interface IncantoTrimOptions {
  /**
  * Keep the in-game scene editor in the build. Default `false` when this
  * plugin is used at all — using it is the request.
  */
  editor?: boolean;
}
/** Minimal plugin shape, so this file needs no vite types. */
interface TrimPlugin {
  name: string;
  apply: "build";
  enforce: "pre";
  resolveId(id: string): string | null;
  load(id: string): string | null;
}
declare function incantoTrim(opts?: IncantoTrimOptions): TrimPlugin;
//#endregion
//#region src/vite/index.d.ts
interface HotUpdateContext {
  file: string;
  read(): Promise<string>;
  server: {
    ws: {
      send(payload: unknown): void;
    };
    config?: {
      logger?: {
        error(msg: string): void;
      };
    };
  };
  modules?: unknown[];
}
interface IncantoScenesOptions {
  /** Hard-fail on unregistered behaviors too (default: structure-only). */
  strictBehaviors?: boolean;
  /**
  * Where scenes are found and written. Default: vite's `root` (your project).
  * Nothing outside it is readable or writable, whatever a request asks for.
  */
  root?: string;
  /**
  * Called after a scene is written through this server — the editor's save,
  * and the editor's create. In-process, with the scene itself; the same
  * event goes to stdout for anything watching the dev server from outside
  * (see {@link SceneEvent}).
  */
  onSave?(event: SceneEvent): void;
}
/**
* What this server announces when a scene lands, on stdout AND to `onSave`.
*
* ONE line per event, `[incanto] ` and a JSON object — readable by a person in
* the terminal they are already watching, unambiguous to a machine, and
* extensible without breaking a parser that only reads the fields it knows:
*
*     [incanto] {"event":"scene:saved","file":"src/game.scene.json","bytes":13284,"at":"2026-09-08T10:19:57.412Z"}
*
* It exists because a container had no way to hear a save that happened inside
* it. The editor a running game hosts writes through `PUT /api/scene`, and the
* only signals available to the process supervising that container were
* accidents: watching the filesystem, or scraping vite's `page reload` line —
* which existed only because saving used to reload the page, and went away
* when that was fixed.
*
* `abs` and `json` are for `onSave` only; the printed line carries neither (an
* absolute container path means nothing outside it, and a scene does not
* belong on one log line).
*/
interface SceneEvent {
  event: "scene:saved" | "scene:created";
  /** Project-relative, forward slashes on every OS. */
  file: string;
  /** Bytes written. */
  bytes: number;
  /** ISO-8601, when it landed. */
  at: string;
  /** Absolute path — `onSave` only, never printed. */
  abs?: string;
  /** The scene as written — `onSave` only, never printed. */
  json?: unknown;
}
/** Hooks the middlewares carry (exported for tests, not for vite). */
interface SceneHooks {
  onSave?(event: SceneEvent): void;
}
declare function incantoScenes(opts?: IncantoScenesOptions): {
  name: string;
  handleHotUpdate(ctx: HotUpdateContext): Promise<undefined | never[]>;
  configureServer(server: SceneDevServer): void;
};
/**
* `GET /api/scenes` → every `*.scene.json` under the project root
* `POST /api/scenes` `{path}` → create a minimal scene there
* `GET /api/scene?file=<rel>` → that scene's JSON
* `PUT /api/scene?file=<rel>` → write it back (bytes verbatim)
*
* These are the routes `incanto-editor` serves, on YOUR dev server, so the
* editor a game switches into is a project editor rather than a single-file
* one: it can list, open, create and save any scene in the project, and play
* whichever one you loaded.
*
* Everything is bounded to the root and to `*.scene.json`. A dev server is
* still a server: `?file=../../.ssh/id_rsa` has to be a 400, not a read.
*/
interface SceneDevServer {
  config?: {
    root?: string;
  };
  middlewares: {
    use(path: string, handler: (req: ApiReq, res: LibraryRes) => void): void;
  };
}
interface ApiReq extends LibraryReq {
  on(event: "data" | "end" | "error", cb: (chunk?: unknown) => void): void;
}
/**
* One JSON file in the project, and whether it is a scene.
*
* A file browser that only shows `*.scene.json` cannot show you the scene you
* saved as `level.json` — and, worse, gives no reason for its absence. So the
* list is every `.json` under the project (a scene is JSON by definition, so
* nothing else can be one), and `scene` says which of them actually are.
*/
interface ProjectFileEntry {
  rel: string;
  abs: string;
  size: number;
  modified: number;
  /** Present only when the file IS a scene — read from the file, not the name. */
  scene?: {
    name: string;
    dimension?: "2d" | "3d";
    nodes: number;
  };
  /** Why it is not one, in a form a person can act on. */
  notScene?: string;
}
/**
* Is this JSON an incanto scene? The file itself answers.
*
* A scene declares what it is — `{"format": 1, "type": "scene", "name", "root"}`
* — and those are exactly the four keys the loader demands before it will build
* anything (`validateHeader`). So "is this a scene" is not a guess from the file
* name; it is a fact readable from the first object in the file. That is what
* lets the browser mark a row ✓ instead of hoping.
*/
declare function sceneFacts(json: unknown): {
  ok: true;
  name: string;
  dimension?: "2d" | "3d";
  nodes: number;
} | {
  ok: false;
  why: string;
};
/**
* The dimension the NEXT scene should be, counted from the ones already here.
*
* Whatever the sibling scenes are is overwhelmingly what the next one should
* be; `null` when the project has no scenes yet and the caller decides.
*/
declare function projectDimension(root: string): "2d" | "3d" | null;
/** @internal Exported for tests. Root-bounded walk, deepest 6 levels. */
declare function discoverScenes(root: string): ProjectFileEntry[];
/**
* @internal The one place a request's path becomes a file path.
*
* `.json` under the project, nothing else — the file browser offers every JSON
* and the loader decides, but a dev server still must not be a way to read
* `.env` or somebody's key file. Content is gated separately: a JSON that is
* not a scene is never sent to the page, only the reason it is not one.
*/
declare function resolveSceneFile(root: string, rel: unknown): string | null;
/** @internal Exported for tests — `GET`/`POST /api/scenes`. */
declare function serveSceneList(req: ApiReq, res: LibraryRes, root: string, hooks?: SceneHooks): Promise<void>;
/** @internal Exported for tests — `GET`/`PUT /api/scene?file=`. */
declare function serveSceneFile(req: ApiReq, res: LibraryRes, root: string, hooks?: SceneHooks): Promise<void>;
interface DevServer {
  middlewares: {
    use(path: string, handler: (req: LibraryReq, res: LibraryRes) => void): void;
  };
}
interface LibraryReq {
  url?: string | undefined;
  method?: string | undefined;
  headers: Record<string, string | string[] | undefined>;
}
interface LibraryRes {
  statusCode: number;
  setHeader(name: string, value: string): void;
  end(body?: string | Uint8Array): void;
}
interface IncantoLibraryOptions {
  /**
  * Verse8 access token. Defaults to INCANTO_V8_TOKEN / V8_ACCESS_TOKEN.
  * Read at request time so a token exported after the server started works.
  */
  token?: string;
  /** Upstream catalog (default: the agent8 backend). */
  url?: string;
  /** Verse8 API root for the sign-in flow (default: the public one). */
  authUrl?: string;
}
/**
* Serve the agent8 asset catalog at `/api/library` on the dev server.
*
* The catalog wants a bearer token and does not CORS-allow localhost, so a page
* cannot call it — but the dev server can, and it is already running. This is
* the same proxy `incanto-editor` ships, so the editor's 📚 works identically
* whether it opened as a page or over a running game.
*
* DEV ONLY (vite `configureServer`): nothing about it reaches a build, and the
* token stays in the terminal that started the server.
*
* ```ts
* // vite.config.ts
* import { incantoLibrary, incantoScenes } from 'incanto/vite';
* export default defineConfig({ plugins: [incantoScenes(), incantoLibrary()] });
* ```
* ```ts
* // main.ts — the editor then offers the library
* createGame3D({ ..., debug: DEV, editor: { library: true } });
* ```
*/
declare function incantoLibrary(opts?: IncantoLibraryOptions): {
  name: string;
  apply: "serve";
  configureServer(server: DevServer): void;
};
/**
* A token, shown the way a wallet address is: enough to recognise WHICH token
* is in use, never enough to use it. Anything short enough that six and four
* characters would give most of it away is hidden entirely.
*/
declare function maskToken(token: string): string;
/** Where the server's token came from, and what it looks like. Never the token. */
declare function serveTokenStatus(req: LibraryReq, res: LibraryRes, opts?: IncantoLibraryOptions): Promise<void>;
/**
* The Verse8 device-authorization flow (RFC 8628), proxied.
*
* The same two calls agent8's own local-dev login makes: `authorize` returns a
* code and a page for the human to approve, `token` is polled until they have.
* It goes through the dev server for the same reason the catalog does — the
* page cannot reach that host itself — and it means a developer never has to
* find, copy or paste a token at all.
*/
declare function serveDeviceAuth(req: LibraryReq, res: LibraryRes, opts?: IncantoLibraryOptions, doFetch?: typeof fetch): Promise<void>;
/** @internal Exported for tests — the whole request/response behaviour. */
declare function serveLibrary(req: LibraryReq, res: LibraryRes, opts?: IncantoLibraryOptions, doFetch?: typeof fetch): Promise<void>;
//#endregion
export { type FrameHost, type FrameReq, type FrameRes, IncantoLibraryOptions, IncantoScenesOptions, type IncantoTrimOptions, ProjectFileEntry, SceneEvent, SceneHooks, type StaticInspectHost, createStaticInspectHost, discoverScenes, incantoLibrary, incantoScenes, incantoTrim, listeningPorts, maskToken, onlyKnownOptions, parseProcNetTcp, projectDimension, resolveSceneFile, sceneFacts, serveDeviceAuth, serveFrameEndpoints, serveLibrary, serveSceneFile, serveSceneList, serveTokenStatus };