@volter/world-core 3.0.38 → 3.0.40

package/src/packRegistry.ts

@@ -182,6 +182,7 @@ export async function pullOnSchedule<T>(vendor: PullVendor, pull: () => Promise<
  */
 export type HostRule = ({ host: string } | { suffix: string } | { hostPattern: string }) & {
   pathPattern?: string;
+  demandPathPattern?: string | false;
   key?: string;
   exclude?: true;
 };
@@ -208,6 +209,8 @@ export type TwinPack = {
   rateBudget?: RateBudgetDeclaration;
   emitter?: TwinEmitter;
   serveExport?: string;
+  /** Declared HTTP transport cap, in bytes; the serve seam and World fronts honor it. */
+  maxRequestBodySize?: number;
   adoption?: {
     sdks?: string[];
     pypi?: string[];
@@ -217,6 +220,9 @@ export type TwinPack = {
     worldIds?: string[];
     tools?: Array<{ package: string; usage: 'build' | 'deployment' }>;
   };
+  /** Why no client case is owed though `adoption.sdks` names npm clients: the vendor maintains no official SDK, or the
+   *  demand's applications use none (architecture, "The descriptor"; `conform`'s client check reads it). */
+  clientCasesNone?: string;
   hosts?: HostRule[];
   hostsNone?: string;
   hostsClaimed?: { door: string; note: string };
@@ -225,7 +231,7 @@ export type TwinPack = {
   /** The door that issues the application the credentials the twin will accept (a key made on the vendor's dashboard,
    *  and whatever names it: a database's URL, a project's id), and the env names it fills, each from a field of the
    *  answer: `init` writes `$issue:<service>` for each, and `up`, once this twin is running, POSTs the body to the door
-   *  and sets each name to its field. A twin that holds its keys (refusing any it
+   *  and sets each name to its field (`file:<field>` materializes one file; `directory:<field>` a relative-file map). A twin that holds its keys (refusing any it
    *  did not issue) declares one, so a World's applications hold keys it issued rather than fixtures it refuses. */
   credentialDoor?: { path: string; body: Record<string, unknown>; fill: Record<string, string> };
   /** Another pack of this vendor issues the API's credentials; architecture, descriptor World wiring. */
@@ -276,10 +282,27 @@ export function packOf(
   const hand = (['stateSystem', 'references', 'rateBudget'] as const).filter((k) => (manifest.descriptor as Record<string, unknown>)[k] !== undefined);
   if (hand.length) throw new Error(`${manifest.vendor}: the descriptor declares ${hand.join(', ')} by hand; the kernel derives them from the manifest (architecture, "The real-system adapters")`);
   const pack: TwinPack = { vendor: manifest.vendor, ...manifest.descriptor, ...(manifest.rateBudget ? { rateBudget: manifest.rateBudget } : {}) };
-  // a pack with no vendor-backed half says why, and derives no adapters
-  if (manifest.vendorBacked?.none) return { ...pack, vendorBacked: { none: manifest.vendorBacked.none } };
+  // a pack with no vendor-backed half says why, and derives no adapters; one whose own surface has none beside lanes
+  // that do derives its lanes' adapters, its own writes settled as the World's (`unsent`)
+  const live = Object.fromEntries(Object.entries(beside).filter(([, l]) => !l.manifest.vendorBacked?.none));
+  if (manifest.vendorBacked?.none && !Object.keys(live).length) return { ...pack, vendorBacked: { none: manifest.vendorBacked.none } };
   if (!surface) return pack;
-  const lanes = 'operations' in surface ? undefined : (surface as Record<string, { manifest: DerivedManifest; surface: DerivedSurface }>);
+  // the unit's own surface: its operations, or a command table (a vendor that carries Redis over HTTP: architecture,
+  // "Other wires"), which names no operation a derived adapter performs; anything else is a map of lanes
+  const ownSurface = 'operations' in surface || 'commands' in surface;
+  if (manifest.vendorBacked?.none && ownSurface) {
+    const own = new Set(((surface as DerivedSurface).operations ?? []).map((o) => o.id));
+    // a command table's every write is the unit's own (no operation of it is performed)
+    const commandTable = !('operations' in surface);
+    const why = manifest.vendorBacked.none;
+    const references = [manifest as unknown as DerivedManifest, ...Object.values(beside).map((l) => l.manifest)].flatMap(derivedReferences);
+    return {
+      ...pack,
+      stateSystem: { ...deriveVendorStateSystem(manifest as unknown as VendorManifest, live), unsent: (input) => (input && typeof input.lane !== 'string' && (commandTable || own.has(String(input.operationId))) ? why : undefined) },
+      ...(references.length ? { references } : {}),
+    };
+  }
+  const lanes = ownSurface ? undefined : (surface as Record<string, { manifest: DerivedManifest; surface: DerivedSurface }>);
   const units = lanes ? Object.values(lanes).map((l) => l.manifest) : [manifest as unknown as DerivedManifest, ...Object.values(beside).map((l) => l.manifest)];
   const references = units.flatMap(derivedReferences);
   return {

package/src/private-transport.ts

@@ -0,0 +1,8 @@
+// Process-local ingress capabilities for byte-stream fronts using an internal request seam.
+// Lazy: importing the pack contract creates no key and opens no process handle.
+const keys = new Map<string, string>();
+export function privateTransportKey(namespace: string): string {
+  let key = keys.get(namespace);
+  if (!key) { key = crypto.randomUUID(); keys.set(namespace, key); }
+  return key;
+}

package/src/protobuf.ts

@@ -69,7 +69,7 @@ function writeScalar(w: Writer, type: string, v: unknown): void {
     case 'bool': w.varint(v ? 1n : 0n); break;
     case 'fixed64': case 'sfixed64': w.fixed(BigInt(v as string), 8); break;
     case 'double': w.fixed(Number(v), 8, true); break;
-    case 'fixed32': case 'sfixed32': w.fixed(Number(v), 4); break;
+    case 'fixed32': case 'sfixed32': w.fixed(BigInt(v as string | number), 4); break;
     case 'float': w.fixed(Number(v), 4, true); break;
     default: throw new Error(`protobuf: ${type} is not a packable scalar`);
   }
@@ -164,7 +164,7 @@ function readScalar(r: Reader, type: string): unknown {
     case 'uint32': return Number(BigInt.asUintN(32, r.varint()));
     case 'int64': return String(BigInt.asIntN(64, r.varint()));
     case 'uint64': return String(BigInt.asUintN(64, r.varint()));
-    case 'sint32': return Number(unzigzag(r.varint()));
+    case 'sint32': return Number(BigInt.asIntN(32, unzigzag(r.varint())));
     case 'sint64': return String(unzigzag(r.varint()));
     case 'bool': return r.varint() !== 0n;
     case 'fixed64': return String(new DataView(r.take(8).slice().buffer).getBigUint64(0, true));
@@ -223,7 +223,9 @@ export function decodeMessage(schema: ProtoSchema, type: string, bytes: Uint8Arr
   const out: Row = {};
   const r = new Reader(bytes);
   while (!r.done) {
-    const key = Number(r.varint());
+    const rawKey = r.varint();
+    if (rawKey > 0xffffffffn) throw new Error('protobuf: field tag exceeds 32 bits');
+    const key = Number(rawKey);
     const number = key >>> 3;
     const wire = key & 7;
     const f = byNumber.get(number);
@@ -232,7 +234,9 @@ export function decodeMessage(schema: ProtoSchema, type: string, bytes: Uint8Arr
       const entry = new Reader(r.bytes());
       let k: unknown; let v: unknown;
       while (!entry.done) {
-        const ek = Number(entry.varint());
+        const rawKey = entry.varint();
+        if (rawKey > 0xffffffffn) throw new Error('protobuf: map field tag exceeds 32 bits');
+        const ek = Number(rawKey);
         if ((ek >>> 3) === 1) k = readValue(schema, entry, { type: f.map.key, kind: 'scalar' }, ek & 7);
         else if ((ek >>> 3) === 2) v = readValue(schema, entry, { type: f.map.value, kind: f.map.valueKind }, ek & 7);
         else entry.skip(ek & 7);

package/src/rateBudget.ts

@@ -194,6 +194,10 @@ export type RateBudgetDeclaration = {
    * review, and the ceiling is the one number that can cost days if it is wrong.
    */
   reason: string;
+  /** The vendor's documented allowance, in calls a minute, and the page that documents it, which the pack cites on a
+   *  `// source:` line (checked like every other vendor fact): required of a budget that admits more than the fallback
+   *  (`scripts/rate-budget-check.ts`). */
+  allowance?: { perMinute: number; source: string };
 };
 
 /**
@@ -203,7 +207,7 @@ export type RateBudgetDeclaration = {
  * pattern. (Declarations are repo source, not user input — this is a performance fix, not a
  * sanitizer.)
  */
-export type RateBudgetPolicy = Required<Omit<RateBudgetDeclaration, 'rules'>> & {
+export type RateBudgetPolicy = Required<Omit<RateBudgetDeclaration, 'rules' | 'allowance'>> & Pick<RateBudgetDeclaration, 'allowance'> & {
   vendor: string;
   rules: RateBudgetWeightRule[];
   /** `compiled[i]` is `rules[i].match`, compiled. Same length, same order. */
@@ -329,6 +333,7 @@ function normalize(vendor: string, decl: RateBudgetDeclaration): RateBudgetPolic
   return {
     vendor,
     reason: decl.reason,
+    ...(decl.allowance ? { allowance: { ...decl.allowance } } : {}),
     windowMs,
     ceiling,
     burstCeiling,