@substrat-run/contracts 0.149.0 → 0.151.0

package/dist/request-trace.d.ts

@@ -0,0 +1,295 @@
+import { z } from 'zod';
+export declare const traceCheckStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"check">;
+    permission: z.ZodString;
+    entity: z.ZodNullable<z.ZodString>;
+    allowed: z.ZodBoolean;
+    decidedBy: z.ZodNullable<z.ZodString>;
+    requires: z.ZodArray<z.ZodString>;
+    callerHas: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const traceSqlStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"sql">;
+    operation: z.ZodEnum<{
+        exec: "exec";
+        query: "query";
+    }>;
+    statement: z.ZodString;
+    params: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    rowsRead: z.ZodOptional<z.ZodNumber>;
+    rowsWritten: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const traceEmitStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"emit">;
+    eventType: z.ZodString;
+    entity: z.ZodString;
+}, z.core.$strip>;
+export declare const traceLogStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"log">;
+    level: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const traceValidationStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"validation">;
+    issues: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const traceOutboundStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"outbound">;
+    host: z.ZodString;
+    path: z.ZodString;
+    method: z.ZodString;
+    status: z.ZodNullable<z.ZodNumber>;
+    outcome: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const traceStoreStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"store">;
+    binding: z.ZodString;
+    operation: z.ZodString;
+    outcome: z.ZodString;
+}, z.core.$strip>;
+export declare const traceErrorStep: z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"error">;
+    code: z.ZodNullable<z.ZodString>;
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const traceStep: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"check">;
+    permission: z.ZodString;
+    entity: z.ZodNullable<z.ZodString>;
+    allowed: z.ZodBoolean;
+    decidedBy: z.ZodNullable<z.ZodString>;
+    requires: z.ZodArray<z.ZodString>;
+    callerHas: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"sql">;
+    operation: z.ZodEnum<{
+        exec: "exec";
+        query: "query";
+    }>;
+    statement: z.ZodString;
+    params: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    rowsRead: z.ZodOptional<z.ZodNumber>;
+    rowsWritten: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"emit">;
+    eventType: z.ZodString;
+    entity: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"log">;
+    level: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"validation">;
+    issues: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"outbound">;
+    host: z.ZodString;
+    path: z.ZodString;
+    method: z.ZodString;
+    status: z.ZodNullable<z.ZodNumber>;
+    outcome: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"store">;
+    binding: z.ZodString;
+    operation: z.ZodString;
+    outcome: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    atMs: z.ZodNumber;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"error">;
+    code: z.ZodNullable<z.ZodString>;
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export declare const traceHead: z.ZodObject<{
+    invocationId: z.ZodString;
+    startedAt: z.ZodString;
+    tenantId: z.ZodString;
+    scopeId: z.ZodNullable<z.ZodString>;
+    vertical: z.ZodNullable<z.ZodString>;
+    surface: z.ZodNullable<z.ZodString>;
+    method: z.ZodNullable<z.ZodString>;
+    path: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodNumber>;
+    threw: z.ZodBoolean;
+    durationMs: z.ZodNumber;
+    level: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+    }>;
+    operation: z.ZodNullable<z.ZodString>;
+    problemCode: z.ZodNullable<z.ZodString>;
+    principalKind: z.ZodNullable<z.ZodString>;
+    principal: z.ZodNullable<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">, z.ZodObject<{
+        system: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        connection: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        capability: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        vertical: z.ZodString;
+        scope: z.core.$ZodBranded<z.ZodString, "ScopeId", "out">;
+    }, z.core.$strip>]>>;
+    eventCount: z.ZodNullable<z.ZodNumber>;
+    eventTypes: z.ZodArray<z.ZodString>;
+    entities: z.ZodArray<z.ZodString>;
+    versionId: z.ZodNullable<z.ZodString>;
+    specVersion: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** What a recorder kept and left out, so a reader never mistakes a thin trace for a quiet call. */
+export declare const traceCapture: z.ZodObject<{
+    sqlParams: z.ZodBoolean;
+    stepsDropped: z.ZodNumber;
+}, z.core.$strip>;
+export declare const requestTrace: z.ZodObject<{
+    invocationId: z.ZodString;
+    startedAt: z.ZodString;
+    tenantId: z.ZodString;
+    scopeId: z.ZodNullable<z.ZodString>;
+    vertical: z.ZodNullable<z.ZodString>;
+    surface: z.ZodNullable<z.ZodString>;
+    method: z.ZodNullable<z.ZodString>;
+    path: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodNumber>;
+    threw: z.ZodBoolean;
+    durationMs: z.ZodNumber;
+    level: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+    }>;
+    operation: z.ZodNullable<z.ZodString>;
+    problemCode: z.ZodNullable<z.ZodString>;
+    principalKind: z.ZodNullable<z.ZodString>;
+    principal: z.ZodNullable<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">, z.ZodObject<{
+        system: z.core.$ZodBranded<z.ZodString, "ModuleId", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        connection: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        capability: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        vertical: z.ZodString;
+        scope: z.core.$ZodBranded<z.ZodString, "ScopeId", "out">;
+    }, z.core.$strip>]>>;
+    eventCount: z.ZodNullable<z.ZodNumber>;
+    eventTypes: z.ZodArray<z.ZodString>;
+    entities: z.ZodArray<z.ZodString>;
+    versionId: z.ZodNullable<z.ZodString>;
+    specVersion: z.ZodNullable<z.ZodString>;
+    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"check">;
+        permission: z.ZodString;
+        entity: z.ZodNullable<z.ZodString>;
+        allowed: z.ZodBoolean;
+        decidedBy: z.ZodNullable<z.ZodString>;
+        requires: z.ZodArray<z.ZodString>;
+        callerHas: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"sql">;
+        operation: z.ZodEnum<{
+            exec: "exec";
+            query: "query";
+        }>;
+        statement: z.ZodString;
+        params: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        rowsRead: z.ZodOptional<z.ZodNumber>;
+        rowsWritten: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"emit">;
+        eventType: z.ZodString;
+        entity: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"log">;
+        level: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"validation">;
+        issues: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"outbound">;
+        host: z.ZodString;
+        path: z.ZodString;
+        method: z.ZodString;
+        status: z.ZodNullable<z.ZodNumber>;
+        outcome: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"store">;
+        binding: z.ZodString;
+        operation: z.ZodString;
+        outcome: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        atMs: z.ZodNumber;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"error">;
+        code: z.ZodNullable<z.ZodString>;
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    capture: z.ZodObject<{
+        sqlParams: z.ZodBoolean;
+        stepsDropped: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RequestTrace = z.infer<typeof requestTrace>;
+//# sourceMappingURL=request-trace.d.ts.map

package/dist/request-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-trace.d.ts","sourceRoot":"","sources":["../src/request-trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,eAAO,MAAM,cAAc;;;;;;;;;;iBASzB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;iBASvB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;iBAKxB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;iBAKvB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;iBAI9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;iBAS5B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;iBAMzB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;iBAMzB,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BASpB,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsBpB,CAAC;AAEH,mGAAmG;AACnG,eAAO,MAAM,YAAY;;;iBAKvB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIvB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/request-trace.js

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+import { actor } from './events.js';
+import { TRACE_STEP_CAP } from './trace-sink.js';
+/**
+ * A recorded request trace (#2358): the head of the hosted invocation line (#1746) plus the
+ * steps inside the call.
+ *
+ * The same shape serves every source. A local recorder fills the whole thing; the hosted
+ * record can fill the head and leave `steps` empty, because a step costs per-call
+ * instrumentation the hosted path samples or skips. A reader therefore treats an empty
+ * `steps` as "not recorded", never as "nothing happened" — which is why `stepsDropped` and
+ * `capture` exist: they say what the recorder kept and what it left out.
+ *
+ * The plain-TypeScript twin of these schemas is `trace-sink.ts`, which the platform entry can
+ * import without zod; `request-trace.test.ts` fails the build if the two disagree.
+ */
+// Not `.int()`: a recorder times with `performance.now()`, and a sub-millisecond SQL statement
+// is the common case. The head's `durationMs` is fractional for the same reason.
+const atMs = z.number().min(0);
+const stepBase = { atMs, durationMs: z.number().min(0).optional() };
+export const traceCheckStep = z.object({
+    type: z.literal('check'),
+    ...stepBase,
+    permission: z.string().min(1),
+    entity: z.string().nullable(),
+    allowed: z.boolean(),
+    decidedBy: z.string().nullable(),
+    requires: z.array(z.string()),
+    callerHas: z.array(z.string()),
+});
+export const traceSqlStep = z.object({
+    type: z.literal('sql'),
+    ...stepBase,
+    operation: z.enum(['query', 'exec']),
+    statement: z.string(),
+    params: z.array(z.unknown()).optional(),
+    rowsRead: z.number().int().min(0).optional(),
+    rowsWritten: z.number().int().min(0).optional(),
+    error: z.string().optional(),
+});
+export const traceEmitStep = z.object({
+    type: z.literal('emit'),
+    ...stepBase,
+    eventType: z.string().min(1),
+    entity: z.string().min(1),
+});
+export const traceLogStep = z.object({
+    type: z.literal('log'),
+    ...stepBase,
+    level: z.string(),
+    message: z.string(),
+});
+export const traceValidationStep = z.object({
+    type: z.literal('validation'),
+    ...stepBase,
+    issues: z.array(z.object({ path: z.string(), message: z.string() })),
+});
+export const traceOutboundStep = z.object({
+    type: z.literal('outbound'),
+    ...stepBase,
+    host: z.string(),
+    path: z.string(),
+    method: z.string(),
+    status: z.number().int().nullable(),
+    outcome: z.string(),
+    reason: z.string().optional(),
+});
+export const traceStoreStep = z.object({
+    type: z.literal('store'),
+    ...stepBase,
+    binding: z.string(),
+    operation: z.string(),
+    outcome: z.string(),
+});
+export const traceErrorStep = z.object({
+    type: z.literal('error'),
+    ...stepBase,
+    code: z.string().nullable(),
+    message: z.string(),
+    stack: z.string().optional(),
+});
+export const traceStep = z.discriminatedUnion('type', [
+    traceCheckStep,
+    traceSqlStep,
+    traceEmitStep,
+    traceLogStep,
+    traceValidationStep,
+    traceOutboundStep,
+    traceStoreStep,
+    traceErrorStep,
+]);
+export const traceHead = z.object({
+    invocationId: z.string().min(1),
+    startedAt: z.string().min(1),
+    tenantId: z.string(),
+    scopeId: z.string().nullable(),
+    vertical: z.string().nullable(),
+    surface: z.string().nullable(),
+    method: z.string().nullable(),
+    path: z.string().nullable(),
+    status: z.number().int().nullable(),
+    threw: z.boolean(),
+    durationMs: z.number().min(0),
+    level: z.enum(['error', 'warn', 'info']),
+    operation: z.string().nullable(),
+    problemCode: z.string().nullable(),
+    principalKind: z.string().nullable(),
+    principal: actor.nullable(),
+    eventCount: z.number().int().min(0).nullable(),
+    eventTypes: z.array(z.string()),
+    entities: z.array(z.string()),
+    versionId: z.string().nullable(),
+    specVersion: z.string().nullable(),
+});
+/** What a recorder kept and left out, so a reader never mistakes a thin trace for a quiet call. */
+export const traceCapture = z.object({
+    /** SQL parameter values were stored (otherwise only the statement text). */
+    sqlParams: z.boolean(),
+    /** Steps past {@link TRACE_STEP_CAP}, counted rather than stored. */
+    stepsDropped: z.number().int().min(0),
+});
+export const requestTrace = z.object({
+    ...traceHead.shape,
+    steps: z.array(traceStep).max(TRACE_STEP_CAP),
+    capture: traceCapture,
+});
+//# sourceMappingURL=request-trace.js.map

package/dist/request-trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-trace.js","sourceRoot":"","sources":["../src/request-trace.ts"],"names":[],"mappings":"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"}

package/dist/trace-sink.d.ts

@@ -0,0 +1,199 @@
+/**
+ * The seam a request trace is recorded through (#2358).
+ *
+ * Plain TypeScript with no runtime import, for the reason `invocation-record.ts` is: the
+ * middleware that feeds a sink is bundled into the platform entry in front of every
+ * vertical, and that bundle may not carry zod. The matching zod schemas — what a recorder
+ * WRITES and `substrat logs` READS — are in `request-trace.ts`; a type-level test holds the
+ * two in step, so this file stays the narrow one without becoming a second source of truth.
+ *
+ * ## How a sink is found
+ *
+ * A host does not take a sink as an option. It reads one slot on `globalThis`,
+ * {@link TRACE_SINK_KEY}, at each hook, and does nothing when the slot is empty. That is the
+ * same arrangement the store-call tally uses, and it is what lets `substrat dev` turn traces
+ * on in a vertical's process with a `--import` preload and no edit to the vertical's
+ * `server.ts`. Nothing on a hosted path ever fills the slot, so "off in production" is a
+ * property of who installs a sink, not of a flag a deploy could forget to set.
+ *
+ * ## What a sink is NOT
+ *
+ * Not authority and not evidence. A trace is a debugging aid for the person running the
+ * vertical locally; nothing reads it to decide a request. A sink that throws must never fail
+ * a request, so a host calls it inside a guard and swallows the error.
+ */
+import type { Actor } from './events.js';
+/** The `globalThis` slot a host reads its sink from. A registered symbol, so two copies of a package agree. */
+export declare const TRACE_SINK_KEY: unique symbol;
+/** The most steps one trace keeps; later ones are counted in `stepsDropped`, not stored. */
+export declare const TRACE_STEP_CAP = 500;
+/** The step kinds, in the order a reader lists them. */
+export declare const TRACE_STEP_TYPES: readonly ['check', 'sql', 'emit', 'log', 'validation', 'outbound', 'store', 'error'];
+export type TraceStepType = (typeof TRACE_STEP_TYPES)[number];
+/** Fields every step carries. */
+interface TraceStepBase {
+    /** Milliseconds from the invocation's start to this step; fractional where the clock is. */
+    atMs: number;
+    /** How long it took, when it has a duration. */
+    durationMs?: number;
+}
+/**
+ * One permission check. `decidedBy` names the path an ALLOW took — `role:<key>`,
+ * `grant:<entity>`, `system:<module>` — read off the proof tuples. A DENY has no rule to
+ * name (the checker returns only the key it checked), so the recorder fills `requires` with
+ * the roles that hold the permission and `callerHas` with the roles the caller holds: that
+ * pair is "requires finance; caller has member". For a check on one entity the missing piece may
+ * be a grant rather than a role, so `requires` also names `grant:<permission>@<entity>` and
+ * `callerHas` lists the grants the caller holds for that permission. `callerHas` is empty for a
+ * subject that is not a principal (a system module, a connection), which holds no role to list:
+ * empty there means "not explained", not "holds nothing".
+ */
+export interface TraceCheckStep extends TraceStepBase {
+    type: 'check';
+    permission: string;
+    /** `<entityType>:<entityId>`, or `null` for a scope-wide check. */
+    entity: string | null;
+    allowed: boolean;
+    decidedBy: string | null;
+    requires: string[];
+    callerHas: string[];
+}
+/**
+ * One `ctx.sql` statement, as it RAN. A statement in an operation that later rolled back (a
+ * refused check, a failed `ctx.atomic`) is still listed: a trace says what the call did, and the
+ * `error` step says how it ended, not which writes survived.
+ *
+ * `params` is present only when the sink asked for it ({@link TraceSink.capture}): a host never
+ * sends values a sink did not request, because a bound value is as likely to be a person's data
+ * or a password hash as an id.
+ */
+export interface TraceSqlStep extends TraceStepBase {
+    type: 'sql';
+    operation: 'query' | 'exec';
+    statement: string;
+    params?: unknown[];
+    /** Rows a `query` returned. */
+    rowsRead?: number;
+    /** Rows an `exec` changed. */
+    rowsWritten?: number;
+    /** The statement's error class and message, when it threw. */
+    error?: string;
+}
+/** One event the operation emitted. Ids and types only — never the payload. */
+export interface TraceEmitStep extends TraceStepBase {
+    type: 'emit';
+    eventType: string;
+    /** `<entityType>:<entityId>`. */
+    entity: string;
+}
+/** One `ctx.log` line the operation wrote. */
+export interface TraceLogStep extends TraceStepBase {
+    type: 'log';
+    level: string;
+    message: string;
+}
+/** The input did not parse. One entry per issue: a dotted path and a message. */
+export interface TraceValidationStep extends TraceStepBase {
+    type: 'validation';
+    issues: {
+        path: string;
+        message: string;
+    }[];
+}
+/** One outbound `fetch`: host, redacted path, method, status and outcome — no header, body or query. */
+export interface TraceOutboundStep extends TraceStepBase {
+    type: 'outbound';
+    host: string;
+    path: string;
+    method: string;
+    status: number | null;
+    outcome: string;
+    /** A failed call's error class, never its message. */
+    reason?: string;
+}
+/** One store call (a blob, a scope store). The input is not a field. */
+export interface TraceStoreStep extends TraceStepBase {
+    type: 'store';
+    binding: string;
+    operation: string;
+    outcome: string;
+}
+/** An error that ended the invocation. `stack` is source-mapped where the host can. */
+export interface TraceErrorStep extends TraceStepBase {
+    type: 'error';
+    code: string | null;
+    message: string;
+    stack?: string;
+}
+export type TraceStep = TraceCheckStep | TraceSqlStep | TraceEmitStep | TraceLogStep | TraceValidationStep | TraceOutboundStep | TraceStoreStep | TraceErrorStep;
+/**
+ * The head of a trace. Every key below is the name the hosted invocation line (#1746) already
+ * uses for the same fact — a rename here would split the two. `null` reads as "not recorded".
+ */
+export interface TraceHead {
+    invocationId: string;
+    /** ISO 8601 instant the invocation started. */
+    startedAt: string;
+    tenantId: string;
+    scopeId: string | null;
+    vertical: string | null;
+    surface: string | null;
+    method: string | null;
+    /** Path only; the query string is dropped. */
+    path: string | null;
+    status: number | null;
+    threw: boolean;
+    durationMs: number;
+    level: 'error' | 'warn' | 'info';
+    operation: string | null;
+    problemCode: string | null;
+    principalKind: string | null;
+    /** Who the call ran as. Local only: the hosted line carries `principalKind` and no id. */
+    principal: Actor | null;
+    eventCount: number | null;
+    eventTypes: string[];
+    entities: string[];
+    versionId: string | null;
+    /** The vertical's spec version, when the host knows it. */
+    specVersion: string | null;
+}
+/**
+ * Two parts of one request report themselves: the HTTP middleware (method, path, status,
+ * duration) and the scope host (operation, principal, events). Each sends the keys it knows.
+ */
+export type TraceHeadPatch = Partial<TraceHead> & {
+    /**
+     * Steps the host knew of and did not send (outbound calls past the cap), so a reader sees a
+     * truncated list as truncated. The recorder adds it to `capture.stepsDropped`.
+     */
+    stepsDropped?: number;
+};
+/**
+ * Where a host sends what it saw. All three are synchronous and best-effort: a recorder
+ * batches and writes elsewhere, and a host calls them inside a guard.
+ */
+export interface TraceSink {
+    /**
+     * What this sink wants a host to send beyond the default. Absent reads as everything off.
+     * `sqlParams` is the one such request today: the values bound to a statement.
+     */
+    readonly capture?: {
+        readonly sqlParams?: boolean;
+    };
+    /** Merge what one part of the host knows about the invocation; `undefined` values are skipped. */
+    head(invocationId: string, patch: TraceHeadPatch): void;
+    /** Append one step. */
+    step(invocationId: string, step: TraceStep): void;
+    /** The invocation is over: the head is as complete as it will get, so write the trace. */
+    end(invocationId: string): void;
+}
+/** Note that an invocation started now (or at `at`, on the `performance.now()` clock). */
+export declare function markTraceStart(invocationId: string, at?: number): void;
+/** Milliseconds since the invocation started, starting it now when nothing has. */
+export declare function traceOffsetMs(invocationId: string): number;
+/** The invocation is over: release its start. */
+export declare function forgetTraceStart(invocationId: string): void;
+/** The sink installed on this runtime, or `undefined` when tracing is off. */
+export declare function installedTraceSink(): TraceSink | undefined;
+export {};
+//# sourceMappingURL=trace-sink.d.ts.map

package/dist/trace-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-sink.d.ts","sourceRoot":"","sources":["../src/trace-sink.ts"],"names":[],"mappings":"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"}