@loutrejs/loutre 0.9.2 → 0.10.0

package/dist/devtools/decoder.js

@@ -0,0 +1,179 @@
+import { runtimeExecutionId } from '../core/identity.js';
+import { epochMilliseconds, milliseconds } from '../core/units.js';
+import { parseCapsuleId, parseRunId, parseSpanId, eventSequence, parseInspectorRequestId, parseTraceId, } from './identity.js';
+import { parseModelNodeId, parseProviderNodeId, } from '../core/model/identity.js';
+export const isDevtoolsRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function optional(value, names, check) {
+    return names.every((name) => value[name] === undefined || check(value[name]));
+}
+function jsonValue(value, ancestors = new Set()) {
+    if (value === null || ['string', 'boolean', 'number'].includes(typeof value))
+        return true;
+    if (typeof value !== 'object' || ancestors.has(value))
+        return false;
+    if (!Array.isArray(value) &&
+        Object.getPrototypeOf(value) !== Object.prototype &&
+        Object.getPrototypeOf(value) !== null)
+        return false;
+    const next = new Set(ancestors).add(value);
+    return Object.values(value).every((child) => jsonValue(child, next));
+}
+function preview(value) {
+    return (isDevtoolsRecord(value) &&
+        typeof value.preview === 'string' &&
+        optional(value, ['truncated', 'redacted'], (item) => typeof item === 'boolean') &&
+        optional(value, ['type'], (item) => typeof item === 'string') &&
+        (value.value === undefined || jsonValue(value.value)));
+}
+function serializedError(value) {
+    return (isDevtoolsRecord(value) &&
+        typeof value.message === 'string' &&
+        optional(value, ['name', 'stack'], (item) => typeof item === 'string'));
+}
+function replayModes(value) {
+    return (Array.isArray(value) &&
+        value.every((mode) => mode === 'direct' || mode === 'transport'));
+}
+export function decodeRuntimeEvent(value) {
+    if (!isDevtoolsRecord(value) ||
+        typeof value.runId !== 'string' ||
+        typeof value.seq !== 'number' ||
+        typeof value.timestamp !== 'number' ||
+        typeof value.traceId !== 'string' ||
+        typeof value.spanId !== 'string')
+        return undefined;
+    if (!optional(value, [
+        'parentSpanId',
+        'graphNodeId',
+        'capsuleId',
+        'replayedFromTraceId',
+        'replayedFromCapsuleId',
+    ], (item) => typeof item === 'string') ||
+        !optional(value, ['replayable'], (item) => typeof item === 'boolean') ||
+        !optional(value, ['attributes'], isDevtoolsRecord) ||
+        !optional(value, ['input', 'result'], preview) ||
+        !optional(value, ['error'], serializedError) ||
+        !optional(value, ['replayModes'], replayModes))
+        return undefined;
+    const base = {
+        runId: parseRunId(value.runId),
+        seq: eventSequence(value.seq),
+        timestamp: epochMilliseconds(value.timestamp),
+        traceId: parseTraceId(value.traceId),
+        spanId: parseSpanId(value.spanId),
+        ...(typeof value.parentSpanId === 'string'
+            ? { parentSpanId: parseSpanId(value.parentSpanId) }
+            : {}),
+        ...(typeof value.graphNodeId === 'string'
+            ? { graphNodeId: parseModelNodeId(value.graphNodeId) }
+            : {}),
+        ...(typeof value.capsuleId === 'string'
+            ? { capsuleId: parseCapsuleId(value.capsuleId) }
+            : {}),
+        ...(typeof value.replayedFromTraceId === 'string'
+            ? { replayedFromTraceId: parseTraceId(value.replayedFromTraceId) }
+            : {}),
+        ...(typeof value.replayedFromCapsuleId === 'string'
+            ? { replayedFromCapsuleId: parseCapsuleId(value.replayedFromCapsuleId) }
+            : {}),
+        ...(typeof value.replayable === 'boolean'
+            ? { replayable: value.replayable }
+            : {}),
+        ...(isDevtoolsRecord(value.attributes)
+            ? { attributes: value.attributes }
+            : {}),
+        ...(preview(value.input) ? { input: value.input } : {}),
+        ...(preview(value.result) ? { result: value.result } : {}),
+        ...(serializedError(value.error) ? { error: value.error } : {}),
+        ...(replayModes(value.replayModes)
+            ? { replayModes: value.replayModes }
+            : {}),
+    };
+    switch (value.type) {
+        case 'execution.started':
+            if (typeof value.executionId !== 'string' ||
+                typeof value.executionKind !== 'string' ||
+                typeof value.name !== 'string')
+                return undefined;
+            return {
+                ...base,
+                type: value.type,
+                executionId: runtimeExecutionId(value.executionId),
+                executionKind: value.executionKind,
+                name: value.name,
+            };
+        case 'span.started':
+            if (typeof value.name !== 'string' || typeof value.kind !== 'string')
+                return undefined;
+            return { ...base, type: value.type, kind: value.kind, name: value.name };
+        case 'execution.ended':
+            if (typeof value.executionId !== 'string')
+                return undefined;
+            if (typeof value.durationMs !== 'number' ||
+                (value.status !== 'ok' &&
+                    value.status !== 'error' &&
+                    value.status !== 'cancelled'))
+                return undefined;
+            return {
+                ...base,
+                type: value.type,
+                executionId: runtimeExecutionId(value.executionId),
+                durationMs: milliseconds(value.durationMs),
+                status: value.status,
+            };
+        case 'span.ended':
+            if (typeof value.durationMs !== 'number' ||
+                (value.status !== 'ok' &&
+                    value.status !== 'error' &&
+                    value.status !== 'cancelled'))
+                return undefined;
+            return {
+                ...base,
+                type: value.type,
+                durationMs: milliseconds(value.durationMs),
+                status: value.status,
+            };
+        default:
+            return undefined;
+    }
+}
+export function decodeInspectorCommand(value) {
+    if (!isDevtoolsRecord(value) || !isDevtoolsRecord(value.request))
+        return undefined;
+    const body = value.request;
+    const requestId = parseInspectorRequestId(body.requestId);
+    if (requestId === undefined)
+        return undefined;
+    if (value.type === 'command.replay-capsule') {
+        const capsuleId = parseCapsuleId(body.capsuleId);
+        if (capsuleId === undefined ||
+            !optional(body, ['parentTraceId'], (item) => typeof item === 'string'))
+            return undefined;
+        return {
+            type: value.type,
+            request: {
+                requestId,
+                capsuleId,
+                ...('inputOverride' in body
+                    ? { inputOverride: body.inputOverride }
+                    : {}),
+                ...(body.parentTraceId === undefined
+                    ? {}
+                    : { parentTraceId: parseTraceId(body.parentTraceId) }),
+            },
+        };
+    }
+    const graphNodeId = parseProviderNodeId(body.graphNodeId);
+    if (graphNodeId === undefined)
+        return undefined;
+    if (value.type === 'command.provider-playground')
+        return { type: value.type, request: { requestId, graphNodeId } };
+    if (value.type === 'command.invoke-provider-method' &&
+        typeof body.method === 'string' &&
+        Array.isArray(body.args))
+        return {
+            type: value.type,
+            request: { requestId, graphNodeId, method: body.method, args: body.args },
+        };
+    return undefined;
+}

package/dist/devtools/identity-internal.d.ts

@@ -0,0 +1,6 @@
+import type { RunId, TraceId, SpanId, CapsuleId, CaptureHandleId } from './identity.js';
+export declare const createRunId: () => RunId;
+export declare const createTraceId: () => TraceId;
+export declare const createSpanId: () => SpanId;
+export declare const createCapsuleId: () => CapsuleId;
+export declare const createCaptureHandleId: () => CaptureHandleId;

package/dist/devtools/identity-internal.js

@@ -0,0 +1,5 @@
+export const createRunId = () => `run_${crypto.randomUUID()}`;
+export const createTraceId = () => `trace_${crypto.randomUUID()}`;
+export const createSpanId = () => `span_${crypto.randomUUID()}`;
+export const createCapsuleId = () => `capsule_${crypto.randomUUID()}`;
+export const createCaptureHandleId = () => `ref_${crypto.randomUUID()}`;

package/dist/devtools/identity.d.ts

@@ -0,0 +1,21 @@
+type DevtoolsId<Kind extends string> = string & {
+    readonly '~loutre.devtools-id': Kind;
+};
+export type RunId = DevtoolsId<'run'>;
+export type TraceId = DevtoolsId<'trace'>;
+export type SpanId = DevtoolsId<'span'>;
+export type CapsuleId = DevtoolsId<'capsule'>;
+export type InspectorRequestId = DevtoolsId<'inspector-request'>;
+export type ControlRequestId = DevtoolsId<'control-request'>;
+export type CaptureHandleId = DevtoolsId<'capture-handle'>;
+export type EventSequence = number & {
+    readonly '~loutre.devtools-sequence': true;
+};
+export declare const parseRunId: (value: unknown) => RunId | undefined;
+export declare const parseTraceId: (value: unknown) => TraceId | undefined;
+export declare const parseSpanId: (value: unknown) => SpanId | undefined;
+export declare const parseCapsuleId: (value: unknown) => CapsuleId | undefined;
+export declare const parseInspectorRequestId: (value: unknown) => InspectorRequestId | undefined;
+export declare const parseControlRequestId: (value: unknown) => ControlRequestId | undefined;
+export declare const eventSequence: (value: number) => EventSequence;
+export {};

package/dist/devtools/identity.js

@@ -0,0 +1,7 @@
+export const parseRunId = (value) => typeof value === 'string' ? value : undefined;
+export const parseTraceId = (value) => typeof value === 'string' ? value : undefined;
+export const parseSpanId = (value) => typeof value === 'string' ? value : undefined;
+export const parseCapsuleId = (value) => typeof value === 'string' ? value : undefined;
+export const parseInspectorRequestId = (value) => typeof value === 'string' ? value : undefined;
+export const parseControlRequestId = (value) => typeof value === 'string' ? value : undefined;
+export const eventSequence = (value) => value;

package/dist/devtools/index.d.ts

@@ -9,3 +9,6 @@ export type { ExecutionEndedEvent, ExecutionStartedEvent, RuntimeEvent, RuntimeE
 export { serializeDevtoolsError } from './observer.js';
 export type { DevtoolsValue, DevtoolsValuePreview, DevtoolsValuePreviewOptions, } from './values.js';
 export { previewDevtoolsValue } from './values.js';
+export * from './identity.js';
+export { decodeRuntimeEvent, decodeInspectorCommand } from './decoder.js';
+export type { InspectorCommand } from './decoder.js';

package/dist/devtools/index.js

@@ -4,3 +4,5 @@ export { ReplayCapsuleStore, } from './capsule.js';
 export { RuntimeDevtoolsInstrumentation } from './runtime.js';
 export { serializeDevtoolsError } from './observer.js';
 export { previewDevtoolsValue } from './values.js';
+export * from './identity.js';
+export { decodeRuntimeEvent, decodeInspectorCommand } from './decoder.js';

package/dist/devtools/inspector.d.ts

@@ -1,23 +1,25 @@
+import type { TraceId, SpanId, CapsuleId, InspectorRequestId } from './identity.js';
+import type { ProviderNodeId } from '../core/model/identity.js';
 import type { SerializedDevtoolsError } from './observer.js';
 import type { DevtoolsValuePreview } from './values.js';
 export interface ReplayExecutionContext {
-    readonly sourceTraceId: string;
-    readonly sourceCapsuleId: string;
-    readonly parentTraceId?: string;
+    readonly sourceTraceId: TraceId;
+    readonly sourceCapsuleId: CapsuleId;
+    readonly parentTraceId?: TraceId;
 }
 export interface ReplayCapsuleRequest {
-    readonly requestId: string;
-    readonly capsuleId: string;
+    readonly requestId: InspectorRequestId;
+    readonly capsuleId: CapsuleId;
     readonly inputOverride?: unknown;
-    readonly parentTraceId?: string;
+    readonly parentTraceId?: TraceId;
 }
 export interface ProviderPlaygroundRequest {
-    readonly requestId: string;
-    readonly graphNodeId: string;
+    readonly requestId: InspectorRequestId;
+    readonly graphNodeId: ProviderNodeId;
 }
 export interface ProviderMethodInvocationRequest {
-    readonly requestId: string;
-    readonly graphNodeId: string;
+    readonly requestId: InspectorRequestId;
+    readonly graphNodeId: ProviderNodeId;
     readonly method: string;
     readonly args: readonly unknown[];
 }
@@ -26,15 +28,15 @@ export interface ProviderPlaygroundMethod {
     readonly arity: number;
 }
 export interface ProviderPlaygroundDescriptor {
-    readonly requestId: string;
-    readonly graphNodeId: string;
+    readonly requestId: InspectorRequestId;
+    readonly graphNodeId: ProviderNodeId;
     readonly providerName: string;
     readonly methods: readonly ProviderPlaygroundMethod[];
 }
 export interface RuntimeInvocationResult {
-    readonly requestId: string;
+    readonly requestId: InspectorRequestId;
     readonly status: 'ok' | 'error';
-    readonly traceId?: string;
+    readonly traceId?: TraceId;
     readonly result?: DevtoolsValuePreview;
     readonly error?: SerializedDevtoolsError;
 }
@@ -44,8 +46,8 @@ export interface RuntimeInspector {
     invokeProviderMethod(request: ProviderMethodInvocationRequest): Promise<RuntimeInvocationResult>;
 }
 export interface RuntimeTraceContext {
-    readonly traceId: string;
-    readonly spanId: string;
+    readonly traceId: TraceId;
+    readonly spanId: SpanId;
 }
 export interface RuntimeDevtoolsContext {
     readonly trace?: RuntimeTraceContext;

package/dist/devtools/observer.d.ts

@@ -1,40 +1,44 @@
-import type { RuntimeExecutionMetadata } from '../core/instrumentation.js';
+import type { RunId, TraceId, SpanId, CapsuleId, EventSequence } from './identity.js';
+import type { ModelNodeId } from '../core/model/identity.js';
+import type { RuntimeExecutionId } from '../core/identity.js';
+import type { EpochMs, DurationMs } from '../core/units.js';
+import type { RuntimeExecutionMetadata, RuntimeOperationMetadata } from '../core/instrumentation.js';
 import type { DevtoolsValuePreview } from './values.js';
-export type RuntimeSpanKind = 'execution' | 'http.request' | 'http.middleware' | 'http.handler' | 'task.handler' | 'message-port.handler' | 'websocket.handler' | 'di.resolve' | 'provider.construct' | 'provider.method' | 'response' | 'dependency' | 'custom';
+export type RuntimeSpanKind = RuntimeOperationMetadata['kind'];
 export interface SerializedDevtoolsError {
     readonly name?: string;
     readonly message: string;
     readonly stack?: string;
 }
 export interface RuntimeEventBase {
-    readonly runId: string;
-    readonly seq: number;
-    readonly timestamp: number;
-    readonly traceId?: string;
-    readonly spanId?: string;
-    readonly parentSpanId?: string;
-    readonly graphNodeId?: string;
+    readonly runId: RunId;
+    readonly seq: EventSequence;
+    readonly timestamp: EpochMs;
+    readonly traceId?: TraceId;
+    readonly spanId?: SpanId;
+    readonly parentSpanId?: SpanId;
+    readonly graphNodeId?: ModelNodeId;
 }
 export interface ExecutionStartedEvent extends RuntimeEventBase {
     readonly type: 'execution.started';
-    readonly traceId: string;
-    readonly spanId: string;
-    readonly executionId: string;
+    readonly traceId: TraceId;
+    readonly spanId: SpanId;
+    readonly executionId: RuntimeExecutionId;
     readonly executionKind: string;
     readonly name: string;
     readonly input?: DevtoolsValuePreview;
-    readonly capsuleId?: string;
+    readonly capsuleId?: CapsuleId;
     readonly replayable?: boolean;
     readonly replayModes?: readonly ('direct' | 'transport')[];
-    readonly replayedFromTraceId?: string;
-    readonly replayedFromCapsuleId?: string;
+    readonly replayedFromTraceId?: TraceId;
+    readonly replayedFromCapsuleId?: CapsuleId;
 }
 export interface ExecutionEndedEvent extends RuntimeEventBase {
     readonly type: 'execution.ended';
-    readonly traceId: string;
-    readonly spanId: string;
-    readonly executionId: string;
-    readonly durationMs: number;
+    readonly traceId: TraceId;
+    readonly spanId: SpanId;
+    readonly executionId: RuntimeExecutionId;
+    readonly durationMs: DurationMs;
     readonly status: 'ok' | 'error' | 'cancelled';
     readonly attributes?: Readonly<Record<string, unknown>>;
     readonly result?: DevtoolsValuePreview;
@@ -42,21 +46,21 @@ export interface ExecutionEndedEvent extends RuntimeEventBase {
 }
 export interface SpanStartedEvent extends RuntimeEventBase {
     readonly type: 'span.started';
-    readonly spanId: string;
-    readonly traceId: string;
+    readonly spanId: SpanId;
+    readonly traceId: TraceId;
     readonly kind: RuntimeSpanKind;
     readonly name: string;
     readonly attributes?: Readonly<Record<string, unknown>>;
     readonly input?: DevtoolsValuePreview;
-    readonly capsuleId?: string;
+    readonly capsuleId?: CapsuleId;
     readonly replayable?: boolean;
     readonly replayModes?: readonly ('direct' | 'transport')[];
 }
 export interface SpanEndedEvent extends RuntimeEventBase {
     readonly type: 'span.ended';
-    readonly spanId: string;
-    readonly traceId: string;
-    readonly durationMs: number;
+    readonly spanId: SpanId;
+    readonly traceId: TraceId;
+    readonly durationMs: DurationMs;
     readonly status: 'ok' | 'error' | 'cancelled';
     readonly attributes?: Readonly<Record<string, unknown>>;
     readonly result?: DevtoolsValuePreview;
@@ -64,14 +68,14 @@ export interface SpanEndedEvent extends RuntimeEventBase {
 }
 export type RuntimeEvent = ExecutionStartedEvent | ExecutionEndedEvent | SpanStartedEvent | SpanEndedEvent;
 export interface RuntimeObserver {
-    readonly runId?: string;
+    readonly runId?: RunId;
     executionStarted?(event: ExecutionStartedEvent): void;
     executionEnded?(event: ExecutionEndedEvent): void;
     spanStarted?(event: SpanStartedEvent): void;
     spanEnded?(event: SpanEndedEvent): void;
 }
 export interface RuntimeExecutionContext extends RuntimeExecutionMetadata {
-    readonly traceId: string;
-    readonly spanId: string;
+    readonly traceId: TraceId;
+    readonly spanId: SpanId;
 }
 export declare function serializeDevtoolsError(error: unknown): SerializedDevtoolsError;

package/dist/devtools/runtime.js

@@ -1,5 +1,9 @@
+import { syntheticExecutionId } from '../core/identity.js';
+import { createRunId, createTraceId, createSpanId, } from './identity-internal.js';
+import { eventSequence } from './identity.js';
+import { monotonicNow, epochFromMonotonic, elapsed, } from '../core/units.js';
 import { ReplayCapsuleStore } from './capsule.js';
-import { serializeDevtoolsError, } from './observer.js';
+import { serializeDevtoolsError } from './observer.js';
 import { discoverProviderMethods, instrumentProviderMethods, } from './provider-instrumentation.js';
 import { previewDevtoolsValue } from './values.js';
 export class RuntimeDevtoolsInstrumentation {
@@ -27,7 +31,7 @@ export class RuntimeDevtoolsInstrumentation {
         const captureResults = options.options.capture?.results;
         this.#captureResults =
             captureResults !== false && captureResults !== 'errors';
-        this.#runId = options.observer.runId ?? `run_${crypto.randomUUID()}`;
+        this.#runId = options.observer.runId ?? createRunId();
         const replay = options.options.replay;
         this.#capsules =
             replay?.enabled === false
@@ -48,10 +52,10 @@ export class RuntimeDevtoolsInstrumentation {
                 });
     }
     beginExecution(metadata, invocation) {
-        const traceId = `trace_${crypto.randomUUID()}`;
-        const spanId = `span_${crypto.randomUUID()}`;
-        const startedAt = performance.now();
-        const startedTimestamp = performance.timeOrigin + startedAt;
+        const traceId = createTraceId();
+        const spanId = createSpanId();
+        const startedAt = monotonicNow();
+        const startedTimestamp = epochFromMonotonic(startedAt);
         const name = metadata.name ?? metadata.executionId;
         const replaySource = this.#context.current()?.replay;
         const capsule = invocation && this.#capsules
@@ -117,12 +121,12 @@ export class RuntimeDevtoolsInstrumentation {
                 const result = resultValues.length === 0
                     ? undefined
                     : this.#previewResult(resultValues[0]);
-                const endedAt = performance.now();
-                const timestamp = performance.timeOrigin + endedAt;
+                const endedAt = monotonicNow();
+                const timestamp = epochFromMonotonic(endedAt);
                 this.#notify('spanEnded', {
                     type: 'span.ended',
                     ...this.#identity(timestamp, traceId, spanId, metadata.graphNodeId),
-                    durationMs: endedAt - startedAt,
+                    durationMs: elapsed(startedAt, endedAt),
                     status,
                     ...(Object.keys(attributes).length === 0 ? {} : { attributes }),
                     ...(result === undefined ? {} : { result }),
@@ -132,7 +136,7 @@ export class RuntimeDevtoolsInstrumentation {
                     type: 'execution.ended',
                     ...this.#identity(timestamp, traceId, spanId, metadata.graphNodeId),
                     executionId: metadata.executionId,
-                    durationMs: endedAt - startedAt,
+                    durationMs: elapsed(startedAt, endedAt),
                     status,
                     ...(Object.keys(attributes).length === 0 ? {} : { attributes }),
                     ...(result === undefined ? {} : { result }),
@@ -145,11 +149,11 @@ export class RuntimeDevtoolsInstrumentation {
         const current = this.#context.current();
         if (!current?.trace)
             return undefined;
-        const spanId = `span_${crypto.randomUUID()}`;
-        const startedAt = performance.now();
+        const spanId = createSpanId();
+        const startedAt = monotonicNow();
         const capsule = invocation && this.#capsules
             ? this.#capsules.createExecution(current.trace.traceId, spanId, {
-                executionId: `span:${metadata.name}`,
+                executionId: syntheticExecutionId(`span:${metadata.name}`),
                 executionKind: metadata.kind,
                 name: metadata.name,
                 ...(metadata.graphNodeId === undefined
@@ -167,8 +171,8 @@ export class RuntimeDevtoolsInstrumentation {
         this.#notify('spanStarted', {
             type: 'span.started',
             runId: this.#runId,
-            seq: ++this.#seq,
-            timestamp: performance.timeOrigin + startedAt,
+            seq: eventSequence(++this.#seq),
+            timestamp: epochFromMonotonic(startedAt),
             traceId: current.trace.traceId,
             spanId,
             parentSpanId: current.trace.spanId,
@@ -206,19 +210,19 @@ export class RuntimeDevtoolsInstrumentation {
                     ? undefined
                     : this.#previewResult(resultValues[0]);
                 const error = failed ? serializeDevtoolsError(failureReason) : undefined;
-                const endedAt = performance.now();
+                const endedAt = monotonicNow();
                 this.#notify('spanEnded', {
                     type: 'span.ended',
                     runId: this.#runId,
-                    seq: ++this.#seq,
-                    timestamp: performance.timeOrigin + endedAt,
+                    seq: eventSequence(++this.#seq),
+                    timestamp: epochFromMonotonic(endedAt),
                     traceId: current.trace.traceId,
                     spanId,
                     parentSpanId: current.trace.spanId,
                     ...(metadata.graphNodeId === undefined
                         ? {}
                         : { graphNodeId: metadata.graphNodeId }),
-                    durationMs: endedAt - startedAt,
+                    durationMs: elapsed(startedAt, endedAt),
                     status: failed ? 'error' : 'ok',
                     ...(Object.keys(attributes).length === 0 ? {} : { attributes }),
                     ...(result === undefined ? {} : { result }),
@@ -356,13 +360,13 @@ export class RuntimeDevtoolsInstrumentation {
         if (!current?.trace) {
             return Reflect.apply(invocation.original, invocation.receiver, invocation.args);
         }
-        const spanId = `span_${crypto.randomUUID()}`;
-        const startedAt = performance.now();
+        const spanId = createSpanId();
+        const startedAt = monotonicNow();
         const name = `${metadata.name}.${invocation.name}`;
         const capsule = metadata.scope === 'transient'
             ? undefined
             : this.#capsules?.createExecution(current.trace.traceId, spanId, {
-                executionId: `${metadata.providerId}.${invocation.name}`,
+                executionId: syntheticExecutionId(`${metadata.providerId}.${invocation.name}`),
                 executionKind: 'provider.method',
                 graphNodeId: metadata.graphNodeId,
                 name,
@@ -394,8 +398,8 @@ export class RuntimeDevtoolsInstrumentation {
         this.#notify('spanStarted', {
             type: 'span.started',
             runId: this.#runId,
-            seq: ++this.#seq,
-            timestamp: performance.timeOrigin + startedAt,
+            seq: eventSequence(++this.#seq),
+            timestamp: epochFromMonotonic(startedAt),
             traceId: parent.traceId,
             spanId,
             parentSpanId: parent.spanId,
@@ -411,18 +415,18 @@ export class RuntimeDevtoolsInstrumentation {
                     replayModes: capsule.replayModes,
                 }),
         });
-        const endedAt = performance.now();
+        const endedAt = monotonicNow();
         const result = outcome.status === 'ok' ? this.#previewResult(outcome.result) : undefined;
         this.#notify('spanEnded', {
             type: 'span.ended',
             runId: this.#runId,
-            seq: ++this.#seq,
-            timestamp: performance.timeOrigin + endedAt,
+            seq: eventSequence(++this.#seq),
+            timestamp: epochFromMonotonic(endedAt),
             traceId: parent.traceId,
             spanId,
             parentSpanId: parent.spanId,
             graphNodeId: metadata.graphNodeId,
-            durationMs: endedAt - startedAt,
+            durationMs: elapsed(startedAt, endedAt),
             status: outcome.status,
             ...(result === undefined ? {} : { result }),
             ...(outcome.status === 'error'
@@ -438,7 +442,7 @@ export class RuntimeDevtoolsInstrumentation {
             throw new TypeError('LUTRE_DEVTOOLS_PROVIDER_ARGS_REQUIRED');
         }
         const scope = this.beginExecution({
-            executionId: `${metadata.providerId}.${method}`,
+            executionId: syntheticExecutionId(`${metadata.providerId}.${method}`),
             executionKind: 'provider.method',
             graphNodeId: metadata.graphNodeId,
             name: `${metadata.name}.${method}`,
@@ -500,7 +504,7 @@ export class RuntimeDevtoolsInstrumentation {
     #identity(timestamp, traceId, spanId, graphNodeId) {
         return {
             runId: this.#runId,
-            seq: ++this.#seq,
+            seq: eventSequence(++this.#seq),
             timestamp,
             traceId,
             spanId,

package/dist/devtools/values.js

@@ -1,9 +1,10 @@
+import { byteLimit, captureDepthLimit, utf8ByteLength } from '../core/units.js';
 import { match } from 'ts-pattern';
 const defaultMaxValueBytes = 64 * 1024;
 const defaultMaxDepth = 8;
 export function previewDevtoolsValue(value, options = {}) {
-    const maxValueBytes = options.maxValueBytes ?? defaultMaxValueBytes;
-    const maxDepth = options.maxDepth ?? defaultMaxDepth;
+    const maxValueBytes = byteLimit(options.maxValueBytes ?? defaultMaxValueBytes);
+    const maxDepth = captureDepthLimit(options.maxDepth ?? defaultMaxDepth);
     const redactions = new Set((options.redact ?? []).map((entry) => entry.trim().toLowerCase()));
     let redacted = false;
     let truncated = false;
@@ -158,9 +159,6 @@ function safeValueType(value) {
         return typeof value;
     }
 }
-function utf8ByteLength(value) {
-    return new TextEncoder().encode(value).byteLength;
-}
 function bytesToBase64(value) {
     let binary = '';
     for (const byte of value)

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.9.2";
+export declare const LOUTRE_VERSION = "0.10.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // package manifestとのずれを避けるため、scripts/generate-version.mjsがbuild前に更新する。
-export const LOUTRE_VERSION = '0.9.2';
+export const LOUTRE_VERSION = '0.10.0';