@volter/world-core 2.0.11 → 2.0.13

package/dist/generated/pack-facts.json

@@ -3590,7 +3590,15 @@
           "supabasemgmt"
         ]
       },
-      "hostsNone": "dual-plane by design: the data plane is the REAL local Supabase stack (external service, app reads discovered SUPABASE_URL); the management twin is app-read via SUPABASE_MGMT_TWIN_URL (cookbook/saas-ai-supabase/app.mjs) — no fixed-host interception wired",
+      "hosts": [
+        {
+          "host": "api.supabase.com"
+        },
+        {
+          "suffix": ".supabase.co",
+          "pathPattern": "^/(rest|storage|auth)/v1(/|$)"
+        }
+      ],
       "archetype": "engine-control",
       "protocol": {
         "major": 1,
@@ -3617,6 +3625,11 @@
         "read_replica",
         "backup"
       ],
+      "managedDatabase": {
+        "kind": "postgres",
+        "arg": "--database",
+        "note": "PostgREST, Storage and Auth are served over the application's own database: the World's managed postgres, the database its migrations and direct queries use"
+      },
       "serveExport": "createSupabaseTwinServer"
     },
     "supermemory": {

package/dist/src/derived-core.d.ts

@@ -163,8 +163,7 @@ export type DerivedManifest = {
         template: string;
         acceptProvided?: boolean;
     };
-    /** operations the derived core must not claim though their resource is declared: served by
-     *  the pack's existing code, or a gap, until someone models them */
+    /** operations the derived core must not claim though their resource is declared: a gap until someone models them */
     unmodeled?: string[];
     /** operations that only read though nothing in the spec says so (a POST that returns data):
      *  a read-only twin answers them */

package/dist/src/derived.d.ts

@@ -54,10 +54,8 @@ export type DerivedFetchOptions = {
     };
     /** An RPC wire: every method is reached by any HTTP method (Slack's clients POST reads too). */
     anyMethod?: boolean;
-    /** The pack's existing fetch while it moves: everything no handler or core owns, and what the core cannot model. */
-    legacy?: (request: Request) => Promise<Response>;
     /** What every operation a handler or the core serves passes through (read-only refusal, version
-     *  checks, idempotent replay); the pack's existing fetch keeps its own while it moves. */
+     *  checks, idempotent replay). */
     around?: (call: DerivedCall, next: () => Promise<Response>) => Promise<Response>;
     /** The vendor's answer for an operation nothing models: the pack's gap. */
     gap: (request: Request, operation: DerivedOperation | undefined, reason: string) => Response;
@@ -74,7 +72,7 @@ export declare function matchOperation(routes: Map<string, Route[]>, method: str
     operation: DerivedOperation;
     params: Record<string, string>;
 } | undefined;
-export type DerivedOwner = 'handler' | 'core' | 'legacy' | 'gap';
+export type DerivedOwner = 'handler' | 'core' | 'gap';
 export type DerivedFetch = ((request: Request) => Promise<Response>) & {
     /** Per operationId, who serves it: a semantics handler, the derived core, the pack's existing
      *  fetch while it moves, or nothing (the vendor's gap). */

package/dist/src/derived.js

@@ -85,7 +85,7 @@ export function createDerivedFetch(options) {
     if (unknown.length)
         throw new Error(`derived dispatch: handlers name operations the surface does not have: ${unknown.sort().join(', ')}`);
     const routes = compileSurface(options.surface);
-    const fallback = (request, operation, reason) => options.legacy ? options.legacy(request) : Promise.resolve(options.gap(request, operation, reason));
+    const fallback = (request, operation, reason) => Promise.resolve(options.gap(request, operation, reason));
     // a valid incoming W3C traceparent scopes the dispatch, so every entry it appends records it (trace-context.ts)
     const fetch = ((request) => runWithRequestTrace(request, () => dispatch(request)));
     const dispatch = async (request) => {
@@ -120,6 +120,6 @@ export function createDerivedFetch(options) {
         }
         return fallback(request, matched.operation, 'no handler');
     };
-    fetch.owners = () => Object.fromEntries(options.surface.operations.map((o) => [o.id, handlers[o.id] ? 'handler' : options.core?.owns(o) ? 'core' : options.legacy ? 'legacy' : 'gap']));
+    fetch.owners = () => Object.fromEntries(options.surface.operations.map((o) => [o.id, handlers[o.id] ? 'handler' : options.core?.owns(o) ? 'core' : 'gap']));
     return fetch;
 }

package/dist/src/packRegistry.d.ts

@@ -307,6 +307,19 @@ export type TwinPack = {
         export: string;
         urlEnv: string;
     };
+    /**
+     * THE WORLD'S MANAGED DATABASE — the declared exception to kernel-held state (docs/contributing/architecture.md,
+     * managed infrastructure: "A vendor whose data plane is a server in front of Postgres"): the pack's data plane is
+     * served over the World's own managed Postgres, which the runtime binds as DATA, never through the environment. At
+     * boot the runtime hands the connection URL of the World's managed `kind` service to the twin: `serve <arg> <url>` on
+     * the spawn path, the factory's `database` option in the colocated host. A World whose database is not its own
+     * managed infrastructure (none declared, or a URL outside it) binds nothing, and the twin refuses its data plane.
+     */
+    managedDatabase?: {
+        kind: 'postgres';
+        arg: string;
+        note: string;
+    };
     /** PROTOCOL 2 — the pack's half of the REAL state system (state-system.ts): perform one entry
      *  against the vendor, refresh the parent log from it, ingest one signed webhook. All over the
      *  kernel executor; the pack never holds a credential. Registered with the pack. */

package/generated/pack-facts.json

@@ -3590,7 +3590,15 @@
           "supabasemgmt"
         ]
       },
-      "hostsNone": "dual-plane by design: the data plane is the REAL local Supabase stack (external service, app reads discovered SUPABASE_URL); the management twin is app-read via SUPABASE_MGMT_TWIN_URL (cookbook/saas-ai-supabase/app.mjs) — no fixed-host interception wired",
+      "hosts": [
+        {
+          "host": "api.supabase.com"
+        },
+        {
+          "suffix": ".supabase.co",
+          "pathPattern": "^/(rest|storage|auth)/v1(/|$)"
+        }
+      ],
       "archetype": "engine-control",
       "protocol": {
         "major": 1,
@@ -3617,6 +3625,11 @@
         "read_replica",
         "backup"
       ],
+      "managedDatabase": {
+        "kind": "postgres",
+        "arg": "--database",
+        "note": "PostgREST, Storage and Auth are served over the application's own database: the World's managed postgres, the database its migrations and direct queries use"
+      },
       "serveExport": "createSupabaseTwinServer"
     },
     "supermemory": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-core",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "description": "The kernel of Volter World: one log per twin, branches as pointers, checkpoints, the fold that keeps a twin current, the head that performs a write against the vendor, references, and the git plane. A twin package builds on it; the runtime serves it.",
   "keywords": [
     "twin",

package/src/derived-core.ts

@@ -147,8 +147,7 @@ export type DerivedManifest = {
    *  (`{prefix}_{n}`), or is `{uuid}` for a vendor whose ids are UUIDs: the next is derived from the resource and its
    *  count, so a World mints the same ids every run */
   ids: { template: string; acceptProvided?: boolean };
-  /** operations the derived core must not claim though their resource is declared: served by
-   *  the pack's existing code, or a gap, until someone models them */
+  /** operations the derived core must not claim though their resource is declared: a gap until someone models them */
   unmodeled?: string[];
   /** operations that only read though nothing in the spec says so (a POST that returns data):
    *  a read-only twin answers them */

package/src/derived.ts

@@ -46,10 +46,8 @@ export type DerivedFetchOptions = {
   core?: { owns: (operation: DerivedOperation) => boolean; serve: (call: DerivedCall) => Promise<DerivedCoreOutcome> };
   /** An RPC wire: every method is reached by any HTTP method (Slack's clients POST reads too). */
   anyMethod?: boolean;
-  /** The pack's existing fetch while it moves: everything no handler or core owns, and what the core cannot model. */
-  legacy?: (request: Request) => Promise<Response>;
   /** What every operation a handler or the core serves passes through (read-only refusal, version
-   *  checks, idempotent replay); the pack's existing fetch keeps its own while it moves. */
+   *  checks, idempotent replay). */
   around?: (call: DerivedCall, next: () => Promise<Response>) => Promise<Response>;
   /** The vendor's answer for an operation nothing models: the pack's gap. */
   gap: (request: Request, operation: DerivedOperation | undefined, reason: string) => Response;
@@ -126,7 +124,7 @@ export function matchOperation(routes: Map<string, Route[]>, method: string, pat
   return undefined;
 }
 
-export type DerivedOwner = 'handler' | 'core' | 'legacy' | 'gap';
+export type DerivedOwner = 'handler' | 'core' | 'gap';
 
 export type DerivedFetch = ((request: Request) => Promise<Response>) & {
   /** Per operationId, who serves it: a semantics handler, the derived core, the pack's existing
@@ -141,7 +139,7 @@ export function createDerivedFetch(options: DerivedFetchOptions): DerivedFetch {
   if (unknown.length) throw new Error(`derived dispatch: handlers name operations the surface does not have: ${unknown.sort().join(', ')}`);
   const routes = compileSurface(options.surface);
   const fallback = (request: Request, operation: DerivedOperation | undefined, reason: string): Promise<Response> =>
-    options.legacy ? options.legacy(request) : Promise.resolve(options.gap(request, operation, reason));
+    Promise.resolve(options.gap(request, operation, reason));
   // a valid incoming W3C traceparent scopes the dispatch, so every entry it appends records it (trace-context.ts)
   const fetch = ((request: Request): Promise<Response> => runWithRequestTrace(request, () => dispatch(request))) as DerivedFetch;
   const dispatch = async (request: Request): Promise<Response> => {
@@ -173,7 +171,7 @@ export function createDerivedFetch(options: DerivedFetchOptions): DerivedFetch {
   };
   fetch.owners = () =>
     Object.fromEntries(
-      options.surface.operations.map((o) => [o.id, handlers[o.id] ? 'handler' : options.core?.owns(o) ? 'core' : options.legacy ? 'legacy' : 'gap'] as const),
+      options.surface.operations.map((o) => [o.id, handlers[o.id] ? 'handler' : options.core?.owns(o) ? 'core' : 'gap'] as const),
     );
   return fetch;
 }

package/src/packRegistry.ts

@@ -330,6 +330,15 @@ export type TwinPack = {
    * never installed by the World: absent from the application, the client is left as it was.
    */
   prismaAdapter?: { adapter: string; export: string; urlEnv: string };
+  /**
+   * THE WORLD'S MANAGED DATABASE — the declared exception to kernel-held state (docs/contributing/architecture.md,
+   * managed infrastructure: "A vendor whose data plane is a server in front of Postgres"): the pack's data plane is
+   * served over the World's own managed Postgres, which the runtime binds as DATA, never through the environment. At
+   * boot the runtime hands the connection URL of the World's managed `kind` service to the twin: `serve <arg> <url>` on
+   * the spawn path, the factory's `database` option in the colocated host. A World whose database is not its own
+   * managed infrastructure (none declared, or a URL outside it) binds nothing, and the twin refuses its data plane.
+   */
+  managedDatabase?: { kind: 'postgres'; arg: string; note: string };
   /** PROTOCOL 2 — the pack's half of the REAL state system (state-system.ts): perform one entry
    *  against the vendor, refresh the parent log from it, ingest one signed webhook. All over the
    *  kernel executor; the pack never holds a credential. Registered with the pack. */