@volter/world-core 3.0.163 → 3.0.165

package/dist/src/index.d.ts

@@ -56,9 +56,10 @@ export type { TwinResource } from './serve.js';
 export { passwordHash, personOf, personWith, recordPerson, shownPersonFields, type Person } from './people.js';
 export { EngineDatabaseError, EngineUnavailableError, quoteIdent } from './managed-database.js';
 export type { Batch as EngineBatch, ManagedDatabase, Statement as EngineStatement, StatementResult as EngineStatementResult } from './managed-database.js';
-export type { Mail, SmtpRoute } from './smtp.js';
+export type { Mail, MailReply } from './smtp.js';
 export * as s3 from './s3/wire.js';
 export * as xml from './xml.js';
+export * as html from './html.js';
 export * as clickhouse from './clickhouse/index.js';
 export { sampleFromSchema } from './schema-sample.js';
 export * as openaiWire from './openai-wire.js';
@@ -67,8 +68,10 @@ export * as protobuf from './protobuf.js';
 export * as grpc from './grpc-wire.js';
 export { acceptH2Connection, type H2Handler, type Http1Handler } from './h2.js';
 export { placeholderPng } from './placeholder-image.js';
+export { imageDimensions, readImageHeader, readMp4Header } from './media-header.js';
 export { presignSigV4, signSigV4, verifySigV4, type SigV4Verdict } from './sigv4.js';
 export * as redis from './redis/index.js';
+export * as smtpServer from './smtp-server.js';
 export * as mysql from './mysql/index.js';
 export * as live from './live/index.js';
 export * as mongodb from './mongodb/index.js';
@@ -76,7 +79,7 @@ export * as git from './git/index.js';
 export { parseScenarioDocument, scenarioFaultResult, ScenarioEngine, ScenarioError } from './scenario.js';
 export type { PackScenarioAdapter, ScenarioDecision, ScenarioDocument, ScenarioExtractorSpec, ScenarioFault, ScenarioFaultResult, ScenarioFeatures, ScenarioHandler, ScenarioMatcher, ScenarioMissRecord, ScenarioStatus } from './scenario.js';
 export { verifyAttestationBundle } from './attestation.js';
-export { browserSessionToken, startBrowserSession, endBrowserSession } from './browser-session.js';
+export { cookieOf, signedIn, browserSessionToken, startBrowserSession, endBrowserSession } from './browser-session.js';
 export { readHostPort } from './host-port.js';
 export { assertBrowserName, browserOrigin, validateBrowserState, validateBrowserStorageState, validateBrowserContext, browserAcceptLanguage, cookieMatchesHost, type BrowserCookie, type BrowserState, type BrowserStorageState, type BrowserContext, type BrowserIndexedDB } from './browser-state.js';
 export * as managedOriginalInputs from './managed-original-inputs.js';

package/dist/src/index.js

@@ -51,6 +51,8 @@ export { EngineDatabaseError, EngineUnavailableError, quoteIdent } from "./manag
 export * as s3 from "./s3/wire.js";
 // Generic strict XML grammar; vendor interpretation remains in its consumer.
 export * as xml from "./xml.js";
+// Generic WHATWG HTML grammar; what a pack keeps of received HTML remains the pack's policy.
+export * as html from "./html.js";
 export * as clickhouse from "./clickhouse/index.js";
 export { sampleFromSchema } from "./schema-sample.js";
 export * as openaiWire from "./openai-wire.js";
@@ -59,8 +61,10 @@ export * as protobuf from "./protobuf.js";
 export * as grpc from "./grpc-wire.js";
 export { acceptH2Connection } from "./h2.js";
 export { placeholderPng } from "./placeholder-image.js";
+export { imageDimensions, readImageHeader, readMp4Header } from "./media-header.js";
 export { presignSigV4, signSigV4, verifySigV4 } from "./sigv4.js";
 export * as redis from "./redis/index.js";
+export * as smtpServer from "./smtp-server.js";
 export * as mysql from "./mysql/index.js";
 export * as live from "./live/index.js";
 export * as mongodb from "./mongodb/index.js";
@@ -68,7 +72,7 @@ export * as git from "./git/index.js";
 // ── the scenario grammar (architecture, "Behaviour") ───────────────────────────────────────────
 export { parseScenarioDocument, scenarioFaultResult, ScenarioEngine, ScenarioError } from "./scenario.js";
 export { verifyAttestationBundle } from "./attestation.js";
-export { browserSessionToken, startBrowserSession, endBrowserSession } from "./browser-session.js";
+export { cookieOf, signedIn, browserSessionToken, startBrowserSession, endBrowserSession } from "./browser-session.js";
 export { readHostPort } from "./host-port.js";
 export { assertBrowserName, browserOrigin, validateBrowserState, validateBrowserStorageState, validateBrowserContext, browserAcceptLanguage, cookieMatchesHost } from "./browser-state.js";
 export * as managedOriginalInputs from "./managed-original-inputs.js";

package/dist/src/managed-database.d.ts

@@ -76,9 +76,11 @@ export declare function managedDatabase(url: string, options?: {
  *  walk/journey-kit.ts), its statements sent as its client sends them: a text alone as one simple Query (a migration
  *  file, a `BEGIN`), a text with values as one extended-protocol statement, the values bind parameters. A transaction it
  *  opens stays open across its statements until it ends it, as on the application's own connection. Each statement's
- *  answer is its results in Postgres's text format, untyped. */
+ *  answer is its results in Postgres's text format, with native column type OIDs retained beside the values. */
 export type DatabaseSession = {
-    query(text: string, values?: ReadonlyArray<string | null>): Promise<StatementResult[]>;
+    query(text: string, values?: ReadonlyArray<string | null>): Promise<Array<StatementResult & {
+        fieldTypes: number[];
+    }>>;
     end(): Promise<void>;
 };
 /** The World's Postgres at `url` as one connection held until `end()`. */

package/dist/src/managed-database.js

@@ -255,6 +255,7 @@ export async function databaseSession(url) {
                 const answer = (await client.query({ text, ...(values === undefined ? {} : { values }), rowMode: 'array', types: raw }));
                 return (Array.isArray(answer) ? answer : [answer]).map((r) => ({
                     fields: (r.fields ?? []).map((f) => f.name),
+                    fieldTypes: (r.fields ?? []).map((f) => f.dataTypeID),
                     rows: r.rows ?? [],
                     command: [r.command ?? '', r.command === 'INSERT' ? '0' : '', r.rowCount ?? ''].filter((part) => part !== '').join(' '),
                 }));

package/dist/src/media-header.d.ts

@@ -0,0 +1,34 @@
+type ImageType = 'image/png' | 'image/gif' | 'image/jpeg' | 'image/webp';
+type Dimensions = {
+    width: number;
+    height: number;
+};
+type ImageHeader = Dimensions & {
+    jpeg?: {
+        frameEnd: number;
+        nonMarkerBytes: boolean;
+        standaloneMarkers: boolean;
+        fillBytes: boolean;
+        shortSegments: boolean;
+    };
+};
+/** Dimensions in a caller-declared image format, or undefined for an incomplete header. */
+export declare function imageDimensions(bytes: Uint8Array, type: ImageType): ImageHeader | undefined;
+/** An image's signature and dimensions, without deciding whether a vendor accepts that format or size. */
+export declare function readImageHeader(bytes: Uint8Array): (ImageHeader & {
+    type: ImageType;
+}) | undefined;
+/** ISO BMFF's bounded top-level boxes and movie headers, with raw duration and 16.16 track dimensions. */
+export declare function readMp4Header(bytes: Uint8Array): {
+    fileType: boolean;
+    hasMediaData: boolean;
+    movies: Array<{
+        headers: Array<{
+            timescale: number;
+            duration: number;
+            payloadSize: number;
+        }>;
+        tracks: Dimensions[];
+    }>;
+};
+export {};

package/dist/src/media-header.js

@@ -0,0 +1,129 @@
+const tag = (bytes, at) => String.fromCharCode(...bytes.subarray(at, at + 4));
+/** Dimensions in a caller-declared image format, or undefined for an incomplete header. */
+export function imageDimensions(bytes, type) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (type === 'image/png')
+        return bytes.length >= 24 ? { width: view.getUint32(16), height: view.getUint32(20) } : undefined;
+    if (type === 'image/gif')
+        return bytes.length >= 10 ? { width: view.getUint16(6, true), height: view.getUint16(8, true) } : undefined;
+    if (type === 'image/webp') {
+        if (bytes.length < 30)
+            return undefined;
+        const chunk = tag(bytes, 12);
+        if (chunk === 'VP8 ')
+            return { width: view.getUint16(26, true) & 0x3fff, height: view.getUint16(28, true) & 0x3fff };
+        if (chunk === 'VP8L') {
+            const bits = view.getUint32(21, true);
+            return { width: 1 + (bits & 0x3fff), height: 1 + ((bits >>> 14) & 0x3fff) };
+        }
+        if (chunk === 'VP8X') {
+            const u24 = (at) => bytes[at] | (bytes[at + 1] << 8) | (bytes[at + 2] << 16);
+            return { width: 1 + u24(24), height: 1 + u24(27) };
+        }
+        return undefined;
+    }
+    let at = 2;
+    const jpeg = { frameEnd: 0, nonMarkerBytes: false, standaloneMarkers: false, fillBytes: false, shortSegments: false };
+    while (at + 4 <= bytes.length) {
+        if (bytes[at] !== 0xff) {
+            jpeg.nonMarkerBytes = true;
+            at += 1;
+            continue;
+        }
+        const marker = bytes[at + 1];
+        if (marker === 0xff) {
+            jpeg.fillBytes = true;
+            at += 1;
+            continue;
+        }
+        if (marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            jpeg.standaloneMarkers = true;
+            at += 2;
+            continue;
+        }
+        const length = view.getUint16(at + 2);
+        if (length < 2)
+            jpeg.shortSegments = true;
+        if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+            return at + 9 <= bytes.length ? { width: view.getUint16(at + 7), height: view.getUint16(at + 5), jpeg: { ...jpeg, frameEnd: at + 9 } } : undefined;
+        }
+        if (marker === 0xda)
+            return undefined;
+        at += 2 + length;
+    }
+    return undefined;
+}
+/** An image's signature and dimensions, without deciding whether a vendor accepts that format or size. */
+export function readImageHeader(bytes) {
+    let type;
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
+        type = 'image/png';
+    else if (tag(bytes, 0).startsWith('GIF'))
+        type = 'image/gif';
+    else if (bytes[0] === 0xff && bytes[1] === 0xd8)
+        type = 'image/jpeg';
+    else if (tag(bytes, 0) === 'RIFF' && tag(bytes, 8) === 'WEBP')
+        type = 'image/webp';
+    else
+        return undefined;
+    const dimensions = imageDimensions(bytes, type);
+    return dimensions ? { type, ...dimensions } : undefined;
+}
+/** ISO BMFF's bounded top-level boxes and movie headers, with raw duration and 16.16 track dimensions. */
+export function readMp4Header(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    function* boxes(from, to) {
+        let at = from;
+        while (at + 8 <= to) {
+            let size = view.getUint32(at);
+            const type = tag(bytes, at + 4);
+            let header = 8;
+            if (size === 1) {
+                if (at + 16 > to)
+                    return;
+                size = Number(view.getBigUint64(at + 8));
+                header = 16;
+            }
+            if (size === 0)
+                size = to - at;
+            if (!Number.isSafeInteger(size) || size < header || size > to - at)
+                return;
+            yield { type, start: at + header, end: at + size };
+            at += size;
+        }
+    }
+    const result = { fileType: bytes.length >= 8 && tag(bytes, 4) === 'ftyp', hasMediaData: false, movies: [] };
+    for (const box of boxes(0, bytes.length)) {
+        if (box.type === 'mdat' && box.end > box.start)
+            result.hasMediaData = true;
+        if (box.type !== 'moov')
+            continue;
+        const movie = { headers: [], tracks: [] };
+        result.movies.push(movie);
+        for (const child of boxes(box.start, box.end)) {
+            const { type, start, end } = child;
+            if (type === 'mvhd' && start < end) {
+                const version = bytes[start];
+                const payloadSize = end - start;
+                if (version === 0 && payloadSize >= 20)
+                    movie.headers.push({ timescale: view.getUint32(start + 12), duration: view.getUint32(start + 16), payloadSize });
+                if (version === 1 && payloadSize >= 32)
+                    movie.headers.push({ timescale: view.getUint32(start + 20), duration: Number(view.getBigUint64(start + 24)), payloadSize });
+            }
+            if (type !== 'trak')
+                continue;
+            for (const track of boxes(start, end)) {
+                if (track.type !== 'tkhd' || track.start >= track.end)
+                    continue;
+                const version = bytes[track.start];
+                const at = version === 1 ? track.start + 88 : version === 0 ? track.start + 76 : track.end;
+                if (at + 8 > track.end)
+                    continue;
+                const width = view.getUint32(at) / 65536;
+                const height = view.getUint32(at + 4) / 65536;
+                movie.tracks.push({ width, height });
+            }
+        }
+    }
+    return result;
+}

package/dist/src/pack-fetch.d.ts

@@ -1,5 +1,5 @@
-import { type DerivedManifest, type Handler, type HandlerContext, type ScreenDecl, type VendorManifest } from './derived-core.js';
-import { type DerivedFetch, type DerivedSurface, type BoardFrame } from './derived.js';
+import { type DerivedManifest, type Handler, type HandlerContext, type LanesDecl, type ScreenDecl, type VendorManifest } from './derived-core.js';
+import { compileSurface, type DerivedFetch, type DerivedSurface, type BoardFrame } from './derived.js';
 import { type PackScenarioAdapter } from './scenario.js';
 import type { ApplicationStandIn } from './events.js';
 import { type SocketEngine } from './sockets.js';
@@ -83,13 +83,34 @@ export type PackFetchOptions = {
     clock?: () => string;
     database?: string;
     scenarioPath?: string;
-    /** the application a walk stands in for (a life's `application` answers): this fetch's `ctx.ask` is answered by it */
+    /** the application a walk stands in for: this fetch's requests and declared events are answered by it */
     application?: ApplicationStandIn;
 };
+/** The host a request is for: the vendor host the World's injector names, else its own. */
+export declare const hostOf: (request: Request) => string;
 /** Where a workspace asked `?show=<type>:<id>` opens the record (architecture, "Workspace"): the built workspace page
  *  that shows that type, its parameter the id; else the one that lists the type; else the workspace's home (its root
  *  page). Every other parameter a page's path names is the asking page's, and a page that cannot be filled is passed
  *  over. Undefined when nothing is asked; the path (with no `show`) otherwise. */
 export declare function shownRecord(url: URL, workspaces: ReadonlyArray<ScreenDecl>, params: Record<string, string>): string | undefined;
+/** A declared World door, matched by the same normalized path for serving and response ownership. */
+export declare function worldDoorMatcher<Door extends {
+    method: string;
+    path: string;
+}>(doors: ReadonlyArray<Door>): (method: string, path: string) => {
+    door: Door;
+    params: Record<string, string>;
+} | undefined;
+/** A request with its path's repeated slashes merged, as a front that merges them routes it (the manifest's
+ *  `mergeSlashes`); one with none is itself. */
+export declare function slashesMerged(request: Request): Request;
+/** The selected unit's request transformation, shared by serving and response judgment. */
+export declare function unitRequestRouter(m: Pick<DerivedManifest, 'pathPrefix' | 'basePathAlias' | 'pathFromHost' | 'hostParams' | 'headerParams'>, surface: DerivedSurface, routes: ReturnType<typeof compileSurface>): (request: Request) => Request;
+/** A pack's HTTP surface, as the kernel serves it from the pack's parts. */
 export declare function createPackFetch(parts: PackParts, options?: PackFetchOptions): DerivedFetch;
+/** The lane selected by the vendor gateway, shared by serving and response judgment. */
+export declare function laneSelector(decl: LanesDecl, lanes: Record<string, {
+    manifest: LanePart['manifest'];
+    fetch: Pick<LanePart['fetch'], 'serves' | 'contentHosts'>;
+}>, rootServes?: (method: string, path: string) => boolean): (request: Request) => string | undefined;
 export declare function createVendorFetch(manifest: VendorManifest, lanes: Record<string, LanePart>): DerivedFetch;