@exaudeus/workrail 0.11.0 → 0.13.0

package/dist/v2/durable-core/schemas/session/events.js

@@ -4,10 +4,21 @@ exports.DomainEventV1Schema = exports.DomainEventEnvelopeV1Schema = void 0;
 const zod_1 = require("zod");
 const json_zod_js_1 = require("../../canonical/json-zod.js");
 const index_js_1 = require("../../ids/index.js");
+const preferences_js_1 = require("./preferences.js");
+const constants_js_1 = require("../../constants.js");
+const decision_trace_ref_js_1 = require("../lib/decision-trace-ref.js");
+const dedupe_key_js_1 = require("../lib/dedupe-key.js");
+const utf8_bounded_string_js_1 = require("../lib/utf8-bounded-string.js");
+function utf8ByteLength(s) {
+    return new TextEncoder().encode(s).length;
+}
 const sha256DigestSchema = zod_1.z
     .string()
-    .regex(/^sha256:[0-9a-f]{64}$/, 'Expected sha256:<64 hex chars>')
+    .regex(constants_js_1.SHA256_DIGEST_PATTERN, 'Expected sha256:<64 hex chars>')
     .describe('sha256 digest in WorkRail v2 format');
+const workflowHashSchema = sha256DigestSchema
+    .transform((v) => (0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(v)))
+    .describe('WorkflowHash (sha256 digest of workflow definition)');
 const snapshotRefSchema = sha256DigestSchema
     .transform((v) => (0, index_js_1.asSnapshotRef)((0, index_js_1.asSha256Digest)(v)))
     .describe('SnapshotRef (content-addressed sha256 ref)');
@@ -17,7 +28,7 @@ exports.DomainEventEnvelopeV1Schema = zod_1.z.object({
     eventIndex: zod_1.z.number().int().nonnegative(),
     sessionId: zod_1.z.string().min(1),
     kind: zod_1.z.string().min(1),
-    dedupeKey: zod_1.z.string().min(1),
+    dedupeKey: dedupe_key_js_1.DedupeKeyV1Schema,
     scope: zod_1.z
         .object({
         runId: zod_1.z.string().min(1).optional(),
@@ -29,7 +40,7 @@ exports.DomainEventEnvelopeV1Schema = zod_1.z.object({
 const WorkflowSourceKindSchema = zod_1.z.enum(['bundled', 'user', 'project', 'remote', 'plugin']);
 const RunStartedDataV1Schema = zod_1.z.object({
     workflowId: zod_1.z.string().min(1),
-    workflowHash: sha256DigestSchema,
+    workflowHash: workflowHashSchema,
     workflowSourceKind: WorkflowSourceKindSchema,
     workflowSourceRef: zod_1.z.string().min(1),
 });
@@ -37,7 +48,7 @@ const NodeKindSchema = zod_1.z.enum(['step', 'checkpoint']);
 const NodeCreatedDataV1Schema = zod_1.z.object({
     nodeKind: NodeKindSchema,
     parentNodeId: zod_1.z.string().min(1).nullable(),
-    workflowHash: sha256DigestSchema,
+    workflowHash: workflowHashSchema,
     snapshotRef: snapshotRefSchema,
 });
 const EdgeKindSchema = zod_1.z.enum(['acked_step', 'checkpoint']);
@@ -65,7 +76,12 @@ const EdgeCreatedDataV1Schema = zod_1.z
 const OutputChannelSchema = zod_1.z.enum(['recap', 'artifact']);
 const NotesPayloadV1Schema = zod_1.z.object({
     payloadKind: zod_1.z.literal('notes'),
-    notesMarkdown: zod_1.z.string().min(1),
+    notesMarkdown: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => utf8ByteLength(s) <= constants_js_1.MAX_OUTPUT_NOTES_MARKDOWN_BYTES, {
+        message: `notesMarkdown exceeds max ${constants_js_1.MAX_OUTPUT_NOTES_MARKDOWN_BYTES} UTF-8 bytes`,
+    }),
 });
 const ArtifactRefPayloadV1Schema = zod_1.z.object({
     payloadKind: zod_1.z.literal('artifact_ref'),
@@ -100,31 +116,57 @@ const BlockerCodeSchema = zod_1.z.enum([
     'STORAGE_CORRUPTION_DETECTED',
 ]);
 const BlockerPointerSchema = zod_1.z.discriminatedUnion('kind', [
-    zod_1.z.object({ kind: zod_1.z.literal('context_key'), key: zod_1.z.string().min(1) }),
+    zod_1.z.object({ kind: zod_1.z.literal('context_key'), key: zod_1.z.string().min(1).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'context_key must be delimiter-safe: [a-z0-9_-]+') }),
+    zod_1.z.object({ kind: zod_1.z.literal('context_budget') }),
     zod_1.z.object({ kind: zod_1.z.literal('output_contract'), contractRef: zod_1.z.string().min(1) }),
     zod_1.z.object({ kind: zod_1.z.literal('capability'), capability: zod_1.z.enum(['delegation', 'web_browsing']) }),
-    zod_1.z.object({ kind: zod_1.z.literal('workflow_step'), stepId: zod_1.z.string().min(1) }),
+    zod_1.z.object({ kind: zod_1.z.literal('workflow_step'), stepId: zod_1.z.string().min(1).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'stepId must be delimiter-safe: [a-z0-9_-]+') }),
 ]);
 const BlockerSchema = zod_1.z.object({
     code: BlockerCodeSchema,
     pointer: BlockerPointerSchema,
-    message: zod_1.z.string().min(1),
-    suggestedFix: zod_1.z.string().min(1).optional(),
+    message: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => utf8ByteLength(s) <= constants_js_1.MAX_BLOCKER_MESSAGE_BYTES, {
+        message: `Blocker message exceeds ${constants_js_1.MAX_BLOCKER_MESSAGE_BYTES} bytes (UTF-8)`,
+    }),
+    suggestedFix: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => utf8ByteLength(s) <= constants_js_1.MAX_BLOCKER_SUGGESTED_FIX_BYTES, {
+        message: `Blocker suggestedFix exceeds ${constants_js_1.MAX_BLOCKER_SUGGESTED_FIX_BYTES} bytes (UTF-8)`,
+    })
+        .optional(),
 });
 const BlockerReportV1Schema = zod_1.z
     .object({
-    blockers: zod_1.z.array(BlockerSchema).min(1).max(10),
+    blockers: zod_1.z.array(BlockerSchema).min(1).max(constants_js_1.MAX_BLOCKERS),
 })
     .superRefine((v, ctx) => {
     const keyFor = (b) => {
         const p = b.pointer;
-        const ptrStable = p.kind === 'context_key'
-            ? p.key
-            : p.kind === 'output_contract'
-                ? p.contractRef
-                : p.kind === 'capability'
-                    ? p.capability
-                    : p.stepId;
+        let ptrStable;
+        switch (p.kind) {
+            case 'context_key':
+                ptrStable = p.key;
+                break;
+            case 'output_contract':
+                ptrStable = p.contractRef;
+                break;
+            case 'capability':
+                ptrStable = p.capability;
+                break;
+            case 'workflow_step':
+                ptrStable = p.stepId;
+                break;
+            case 'context_budget':
+                ptrStable = '';
+                break;
+            default:
+                const _exhaustive = p;
+                ptrStable = _exhaustive;
+        }
         return `${b.code}|${p.kind}|${String(ptrStable)}`;
     };
     for (let i = 1; i < v.blockers.length; i++) {
@@ -147,21 +189,19 @@ const AdvanceRecordedDataV1Schema = zod_1.z.object({
     intent: zod_1.z.literal('ack_pending'),
     outcome: AdvanceRecordedOutcomeV1Schema,
 });
-const AutonomySchema = zod_1.z.enum(['guided', 'full_auto_stop_on_user_deps', 'full_auto_never_stop']);
-const RiskPolicySchema = zod_1.z.enum(['conservative', 'balanced', 'aggressive']);
 const PreferencesChangedDataV1Schema = zod_1.z
     .object({
     changeId: zod_1.z.string().min(1),
     source: zod_1.z.enum(['user', 'workflow_recommendation', 'system']),
     delta: zod_1.z
         .array(zod_1.z.discriminatedUnion('key', [
-        zod_1.z.object({ key: zod_1.z.literal('autonomy'), value: AutonomySchema }),
-        zod_1.z.object({ key: zod_1.z.literal('riskPolicy'), value: RiskPolicySchema }),
+        zod_1.z.object({ key: zod_1.z.literal('autonomy'), value: preferences_js_1.AutonomyV2Schema }),
+        zod_1.z.object({ key: zod_1.z.literal('riskPolicy'), value: preferences_js_1.RiskPolicyV2Schema }),
     ]))
         .min(1),
     effective: zod_1.z.object({
-        autonomy: AutonomySchema,
-        riskPolicy: RiskPolicySchema,
+        autonomy: preferences_js_1.AutonomyV2Schema,
+        riskPolicy: preferences_js_1.RiskPolicyV2Schema,
     }),
 })
     .superRefine((v, ctx) => {
@@ -212,7 +252,7 @@ exports.DomainEventV1Schema = zod_1.z.discriminatedUnion('kind', [
         data: zod_1.z.object({
             key: zod_1.z.enum(['git_branch', 'git_head_sha', 'repo_root_hash']),
             value: zod_1.z.discriminatedUnion('type', [
-                zod_1.z.object({ type: zod_1.z.literal('short_string'), value: zod_1.z.string().min(1).max(80) }),
+                zod_1.z.object({ type: zod_1.z.literal('short_string'), value: zod_1.z.string().min(1).max(constants_js_1.MAX_OBSERVATION_SHORT_STRING_LENGTH) }),
                 zod_1.z.object({ type: zod_1.z.literal('git_sha1'), value: zod_1.z.string().regex(/^[0-9a-f]{40}$/) }),
                 zod_1.z.object({ type: zod_1.z.literal('sha256'), value: sha256DigestSchema }),
             ]),
@@ -317,16 +357,21 @@ exports.DomainEventV1Schema = zod_1.z.discriminatedUnion('kind', [
     exports.DomainEventEnvelopeV1Schema.extend({
         kind: zod_1.z.literal('decision_trace_appended'),
         scope: zod_1.z.object({ runId: zod_1.z.string().min(1), nodeId: zod_1.z.string().min(1) }),
-        data: zod_1.z.object({
+        data: zod_1.z
+            .object({
             traceId: zod_1.z.string().min(1),
             entries: zod_1.z
                 .array(zod_1.z.object({
                 kind: zod_1.z.enum(['selected_next_step', 'evaluated_condition', 'entered_loop', 'exited_loop', 'detected_non_tip_advance']),
-                summary: zod_1.z.string().min(1).max(512),
-                refs: zod_1.z.record(zod_1.z.unknown()).optional(),
+                summary: (0, utf8_bounded_string_js_1.utf8BoundedString)({ maxBytes: constants_js_1.MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES, label: 'decision trace entry summary', minLength: 1 }),
+                refs: decision_trace_ref_js_1.DecisionTraceRefsV1Schema,
             }))
                 .min(1)
-                .max(25),
-        }),
+                .max(constants_js_1.MAX_DECISION_TRACE_ENTRIES),
+        })
+            .refine((data) => {
+            const totalBytes = data.entries.reduce((sum, entry) => sum + utf8ByteLength(entry.summary), 0);
+            return totalBytes <= constants_js_1.MAX_DECISION_TRACE_TOTAL_BYTES;
+        }, { message: `Decision trace total bytes exceeds ${constants_js_1.MAX_DECISION_TRACE_TOTAL_BYTES}` }),
     }),
 ]);

package/dist/v2/durable-core/schemas/session/manifest.d.ts

@@ -6,7 +6,7 @@ export declare const ManifestRecordV1Schema: z.ZodDiscriminatedUnion<"kind", [z.
     kind: z.ZodLiteral<"segment_closed">;
     firstEventIndex: z.ZodNumber;
     lastEventIndex: z.ZodNumber;
-    segmentRelPath: z.ZodString;
+    segmentRelPath: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     sha256: z.ZodString;
     bytes: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
@@ -41,17 +41,17 @@ export declare const ManifestRecordV1Schema: z.ZodDiscriminatedUnion<"kind", [z.
     kind: "snapshot_pinned";
     sessionId: string;
     v: 1;
+    manifestIndex: number;
     eventIndex: number;
     snapshotRef: string;
-    manifestIndex: number;
     createdByEventId: string;
 }, {
     kind: "snapshot_pinned";
     sessionId: string;
     v: 1;
+    manifestIndex: number;
     eventIndex: number;
     snapshotRef: string;
-    manifestIndex: number;
     createdByEventId: string;
 }>]>;
 export type ManifestRecordV1 = z.infer<typeof ManifestRecordV1Schema>;

package/dist/v2/durable-core/schemas/session/manifest.js

@@ -6,6 +6,11 @@ const sha256DigestSchema = zod_1.z
     .string()
     .regex(/^sha256:[0-9a-f]{64}$/, 'Expected sha256:<64 hex chars>')
     .describe('sha256 digest in WorkRail v2 format');
+const relativePathSchema = zod_1.z
+    .string()
+    .min(1)
+    .refine((path) => !path.startsWith('/') && !path.startsWith('\\'), 'Path must be relative (no absolute paths)')
+    .refine((path) => !path.includes('../') && !path.includes('..\\'), 'Path must not contain path traversal (..)');
 exports.ManifestRecordV1Schema = zod_1.z.discriminatedUnion('kind', [
     zod_1.z.object({
         v: zod_1.z.literal(1),
@@ -14,7 +19,7 @@ exports.ManifestRecordV1Schema = zod_1.z.discriminatedUnion('kind', [
         kind: zod_1.z.literal('segment_closed'),
         firstEventIndex: zod_1.z.number().int().nonnegative(),
         lastEventIndex: zod_1.z.number().int().nonnegative(),
-        segmentRelPath: zod_1.z.string().min(1),
+        segmentRelPath: relativePathSchema,
         sha256: sha256DigestSchema,
         bytes: zod_1.z.number().int().nonnegative(),
     }),

package/dist/v2/durable-core/schemas/session/preferences.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export type AutonomyV2 = 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';
+export type RiskPolicyV2 = 'conservative' | 'balanced' | 'aggressive';
+export declare const AutonomyV2Schema: z.ZodEnum<["guided", "full_auto_stop_on_user_deps", "full_auto_never_stop"]>;
+export declare const RiskPolicyV2Schema: z.ZodEnum<["conservative", "balanced", "aggressive"]>;

package/dist/v2/durable-core/schemas/session/preferences.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskPolicyV2Schema = exports.AutonomyV2Schema = void 0;
+const zod_1 = require("zod");
+exports.AutonomyV2Schema = zod_1.z.enum(['guided', 'full_auto_stop_on_user_deps', 'full_auto_never_stop']);
+exports.RiskPolicyV2Schema = zod_1.z.enum(['conservative', 'balanced', 'aggressive']);

package/dist/v2/durable-core/schemas/session/session-health.d.ts

@@ -10,6 +10,9 @@ export type CorruptionReasonV2 = {
 } | {
     readonly code: 'unknown_schema_version';
     readonly message: string;
+} | {
+    readonly code: 'schema_validation_failed';
+    readonly message: string;
 };
 export type SessionHealthV2 = {
     readonly kind: 'healthy';

package/dist/v2/durable-core/tokens/index.d.ts

@@ -1,7 +1,8 @@
-export { encodeBase64Url, decodeBase64Url } from './base64url.js';
 export { TokenPayloadV1Schema, StateTokenPayloadV1Schema, AckTokenPayloadV1Schema, CheckpointTokenPayloadV1Schema, expectedPrefixForTokenKind, } from './payloads.js';
 export type { TokenPayloadV1, StateTokenPayloadV1, AckTokenPayloadV1, CheckpointTokenPayloadV1 } from './payloads.js';
 export { encodeTokenPayloadV1, encodeUnsignedTokenV1, parseTokenV1 } from './token-codec.js';
 export type { TokenDecodeErrorV2, ParsedTokenV1 } from './token-codec.js';
 export { signTokenV1, verifyTokenSignatureV1, assertTokenScopeMatchesState } from './token-signer.js';
 export type { TokenVerifyErrorV2 } from './token-signer.js';
+export type { AttemptId, OutputId } from '../ids/index.js';
+export { asAttemptId, asOutputId } from '../ids/index.js';

package/dist/v2/durable-core/tokens/index.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertTokenScopeMatchesState = exports.verifyTokenSignatureV1 = exports.signTokenV1 = exports.parseTokenV1 = exports.encodeUnsignedTokenV1 = exports.encodeTokenPayloadV1 = exports.expectedPrefixForTokenKind = exports.CheckpointTokenPayloadV1Schema = exports.AckTokenPayloadV1Schema = exports.StateTokenPayloadV1Schema = exports.TokenPayloadV1Schema = exports.decodeBase64Url = exports.encodeBase64Url = void 0;
-var base64url_js_1 = require("./base64url.js");
-Object.defineProperty(exports, "encodeBase64Url", { enumerable: true, get: function () { return base64url_js_1.encodeBase64Url; } });
-Object.defineProperty(exports, "decodeBase64Url", { enumerable: true, get: function () { return base64url_js_1.decodeBase64Url; } });
+exports.asOutputId = exports.asAttemptId = exports.assertTokenScopeMatchesState = exports.verifyTokenSignatureV1 = exports.signTokenV1 = exports.parseTokenV1 = exports.encodeUnsignedTokenV1 = exports.encodeTokenPayloadV1 = exports.expectedPrefixForTokenKind = exports.CheckpointTokenPayloadV1Schema = exports.AckTokenPayloadV1Schema = exports.StateTokenPayloadV1Schema = exports.TokenPayloadV1Schema = void 0;
 var payloads_js_1 = require("./payloads.js");
 Object.defineProperty(exports, "TokenPayloadV1Schema", { enumerable: true, get: function () { return payloads_js_1.TokenPayloadV1Schema; } });
 Object.defineProperty(exports, "StateTokenPayloadV1Schema", { enumerable: true, get: function () { return payloads_js_1.StateTokenPayloadV1Schema; } });
@@ -18,3 +15,6 @@ var token_signer_js_1 = require("./token-signer.js");
 Object.defineProperty(exports, "signTokenV1", { enumerable: true, get: function () { return token_signer_js_1.signTokenV1; } });
 Object.defineProperty(exports, "verifyTokenSignatureV1", { enumerable: true, get: function () { return token_signer_js_1.verifyTokenSignatureV1; } });
 Object.defineProperty(exports, "assertTokenScopeMatchesState", { enumerable: true, get: function () { return token_signer_js_1.assertTokenScopeMatchesState; } });
+var index_js_1 = require("../ids/index.js");
+Object.defineProperty(exports, "asAttemptId", { enumerable: true, get: function () { return index_js_1.asAttemptId; } });
+Object.defineProperty(exports, "asOutputId", { enumerable: true, get: function () { return index_js_1.asOutputId; } });

package/dist/v2/durable-core/tokens/payloads.d.ts

@@ -17,20 +17,20 @@ export declare const StateTokenPayloadV1Schema: z.ZodObject<{
     sessionId: string & {
         readonly __brand: "v2.SessionId";
     };
-    workflowHash: never;
     runId: string & {
         readonly __brand: "v2.RunId";
     };
     nodeId: string & {
         readonly __brand: "v2.NodeId";
     };
+    workflowHash: never;
     tokenVersion: 1;
     tokenKind: "state";
 }, {
     sessionId: string;
-    workflowHash: string;
     runId: string;
     nodeId: string;
+    workflowHash: string;
     tokenVersion: 1;
     tokenKind: "state";
 }>;
@@ -129,20 +129,20 @@ export declare const TokenPayloadV1Schema: z.ZodDiscriminatedUnion<"tokenKind",
     sessionId: string & {
         readonly __brand: "v2.SessionId";
     };
-    workflowHash: never;
     runId: string & {
         readonly __brand: "v2.RunId";
     };
     nodeId: string & {
         readonly __brand: "v2.NodeId";
     };
+    workflowHash: never;
     tokenVersion: 1;
     tokenKind: "state";
 }, {
     sessionId: string;
-    workflowHash: string;
     runId: string;
     nodeId: string;
+    workflowHash: string;
     tokenVersion: 1;
     tokenKind: "state";
 }>, z.ZodObject<{

package/dist/v2/durable-core/tokens/token-codec.d.ts

@@ -1,6 +1,7 @@
 import type { Result } from 'neverthrow';
 import type { CanonicalBytes } from '../ids/index.js';
 import type { TokenStringV1 } from '../ids/index.js';
+import type { Base64UrlPortV2 } from '../../ports/base64url.port.js';
 import { type TokenPayloadV1, type TokenPrefixV1 } from './payloads.js';
 export type TokenDecodeErrorV2 = {
     readonly code: 'TOKEN_INVALID_FORMAT';
@@ -24,8 +25,8 @@ export interface ParsedTokenV1 {
     readonly payload: TokenPayloadV1;
 }
 export declare function encodeTokenPayloadV1(payload: TokenPayloadV1): Result<CanonicalBytes, TokenDecodeErrorV2>;
-export declare function encodeUnsignedTokenV1(payload: TokenPayloadV1): Result<{
+export declare function encodeUnsignedTokenV1(payload: TokenPayloadV1, base64url: Base64UrlPortV2): Result<{
     readonly token: TokenStringV1;
     readonly payloadBytes: CanonicalBytes;
 }, TokenDecodeErrorV2>;
-export declare function parseTokenV1(token: string): Result<ParsedTokenV1, TokenDecodeErrorV2>;
+export declare function parseTokenV1(token: string, base64url: Base64UrlPortV2): Result<ParsedTokenV1, TokenDecodeErrorV2>;

package/dist/v2/durable-core/tokens/token-codec.js

@@ -6,7 +6,6 @@ exports.parseTokenV1 = parseTokenV1;
 const neverthrow_1 = require("neverthrow");
 const jcs_js_1 = require("../canonical/jcs.js");
 const index_js_1 = require("../ids/index.js");
-const base64url_js_1 = require("./base64url.js");
 const payloads_js_1 = require("./payloads.js");
 function encodeTokenPayloadV1(payload) {
     return (0, jcs_js_1.toCanonicalBytes)(payload).mapErr((e) => ({
@@ -14,15 +13,15 @@ function encodeTokenPayloadV1(payload) {
         message: e.message,
     }));
 }
-function encodeUnsignedTokenV1(payload) {
+function encodeUnsignedTokenV1(payload, base64url) {
     const bytes = encodeTokenPayloadV1(payload);
     if (bytes.isErr())
         return (0, neverthrow_1.err)(bytes.error);
     const prefix = (0, payloads_js_1.expectedPrefixForTokenKind)(payload.tokenKind);
-    const token = `${prefix}.v1.${(0, base64url_js_1.encodeBase64Url)(bytes.value)}.`;
+    const token = `${prefix}.v1.${base64url.encodeBase64Url(bytes.value)}.`;
     return (0, neverthrow_1.ok)({ token: (0, index_js_1.asTokenStringV1)(token), payloadBytes: bytes.value });
 }
-function parseTokenV1(token) {
+function parseTokenV1(token, base64url) {
     const parts = token.split('.');
     if (parts.length !== 4)
         return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: 'Expected 4 dot-separated segments' });
@@ -35,13 +34,20 @@ function parseTokenV1(token) {
     if (payloadB64.trim() === '' || sigB64.trim() === '') {
         return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: 'Missing payload or signature segment' });
     }
-    const decoded = (0, base64url_js_1.decodeBase64Url)(payloadB64);
+    const decoded = base64url.decodeBase64Url(payloadB64);
     if (decoded.isErr())
         return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: decoded.error.message });
     const payloadBytes = (0, index_js_1.asCanonicalBytes)(decoded.value);
+    let payloadText;
+    try {
+        payloadText = new TextDecoder('utf-8', { fatal: true }).decode(payloadBytes);
+    }
+    catch {
+        return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: 'Payload is not valid UTF-8' });
+    }
     let payloadJson;
     try {
-        payloadJson = JSON.parse(new TextDecoder().decode(payloadBytes));
+        payloadJson = JSON.parse(payloadText);
     }
     catch {
         return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: 'Payload is not valid JSON' });

package/dist/v2/durable-core/tokens/token-signer.d.ts

@@ -1,6 +1,7 @@
 import type { Result } from 'neverthrow';
 import type { HmacSha256PortV2 } from '../../ports/hmac-sha256.port.js';
 import type { KeyringV1 } from '../../ports/keyring.port.js';
+import type { Base64UrlPortV2 } from '../../ports/base64url.port.js';
 import type { CanonicalBytes, TokenStringV1 } from '../ids/index.js';
 import type { ParsedTokenV1, TokenDecodeErrorV2 } from './token-codec.js';
 export type TokenVerifyErrorV2 = {
@@ -10,6 +11,6 @@ export type TokenVerifyErrorV2 = {
     readonly code: 'TOKEN_INVALID_FORMAT';
     readonly message: string;
 };
-export declare function signTokenV1(unsignedTokenPrefix: 'st.v1.' | 'ack.v1.' | 'chk.v1.', payloadBytes: CanonicalBytes, keyring: KeyringV1, hmac: HmacSha256PortV2): Result<TokenStringV1, TokenVerifyErrorV2>;
-export declare function verifyTokenSignatureV1(parsed: ParsedTokenV1, keyring: KeyringV1, hmac: HmacSha256PortV2): Result<void, TokenVerifyErrorV2>;
+export declare function signTokenV1(unsignedTokenPrefix: 'st.v1.' | 'ack.v1.' | 'chk.v1.', payloadBytes: CanonicalBytes, keyring: KeyringV1, hmac: HmacSha256PortV2, base64url: Base64UrlPortV2): Result<TokenStringV1, TokenVerifyErrorV2>;
+export declare function verifyTokenSignatureV1(parsed: ParsedTokenV1, keyring: KeyringV1, hmac: HmacSha256PortV2, base64url: Base64UrlPortV2): Result<void, TokenVerifyErrorV2>;
 export declare function assertTokenScopeMatchesState(state: ParsedTokenV1, other: ParsedTokenV1): Result<void, TokenDecodeErrorV2>;

package/dist/v2/durable-core/tokens/token-signer.js

@@ -4,26 +4,25 @@ exports.signTokenV1 = signTokenV1;
 exports.verifyTokenSignatureV1 = verifyTokenSignatureV1;
 exports.assertTokenScopeMatchesState = assertTokenScopeMatchesState;
 const neverthrow_1 = require("neverthrow");
-const base64url_js_1 = require("./base64url.js");
 const index_js_1 = require("../ids/index.js");
-function decodeKeyBytes(keyBase64Url) {
-    const decoded = (0, base64url_js_1.decodeBase64Url)(keyBase64Url);
+function decodeKeyBytes(keyBase64Url, base64url) {
+    const decoded = base64url.decodeBase64Url(keyBase64Url);
     if (decoded.isErr())
         return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: 'Invalid key encoding' });
     if (decoded.value.length !== 32)
         return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: 'Invalid key length' });
     return (0, neverthrow_1.ok)(decoded.value);
 }
-function signTokenV1(unsignedTokenPrefix, payloadBytes, keyring, hmac) {
-    const key = decodeKeyBytes(keyring.current.keyBase64Url);
+function signTokenV1(unsignedTokenPrefix, payloadBytes, keyring, hmac, base64url) {
+    const key = decodeKeyBytes(keyring.current.keyBase64Url, base64url);
     if (key.isErr())
         return (0, neverthrow_1.err)(key.error);
     const sig = hmac.hmacSha256(key.value, payloadBytes);
-    const token = `${unsignedTokenPrefix}${(0, base64url_js_1.encodeBase64Url)(payloadBytes)}.${(0, base64url_js_1.encodeBase64Url)(sig)}`;
+    const token = `${unsignedTokenPrefix}${base64url.encodeBase64Url(payloadBytes)}.${base64url.encodeBase64Url(sig)}`;
     return (0, neverthrow_1.ok)((0, index_js_1.asTokenStringV1)(token));
 }
-function verifyTokenSignatureV1(parsed, keyring, hmac) {
-    const sigBytes = (0, base64url_js_1.decodeBase64Url)(parsed.sigBase64Url);
+function verifyTokenSignatureV1(parsed, keyring, hmac, base64url) {
+    const sigBytes = base64url.decodeBase64Url(parsed.sigBase64Url);
     if (sigBytes.isErr())
         return (0, neverthrow_1.err)({ code: 'TOKEN_INVALID_FORMAT', message: 'Invalid signature encoding' });
     if (sigBytes.value.length !== 32)
@@ -32,7 +31,7 @@ function verifyTokenSignatureV1(parsed, keyring, hmac) {
     if (keyring.previous)
         keys.push(keyring.previous.keyBase64Url);
     for (const k of keys) {
-        const key = decodeKeyBytes(k);
+        const key = decodeKeyBytes(k, base64url);
         if (key.isErr())
             continue;
         const expected = hmac.hmacSha256(key.value, parsed.payloadBytes);

package/dist/v2/infra/local/base64url/index.d.ts

@@ -0,0 +1,5 @@
+import type { Base64UrlPortV2 } from '../../../ports/base64url.port.js';
+export declare class NodeBase64UrlV2 implements Base64UrlPortV2 {
+    encodeBase64Url(bytes: Uint8Array): string;
+    decodeBase64Url(input: string): ReturnType<Base64UrlPortV2['decodeBase64Url']>;
+}

package/dist/v2/infra/local/base64url/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeBase64UrlV2 = void 0;
+const neverthrow_1 = require("neverthrow");
+const node_buffer_1 = require("node:buffer");
+class NodeBase64UrlV2 {
+    encodeBase64Url(bytes) {
+        return node_buffer_1.Buffer.from(bytes).toString('base64url');
+    }
+    decodeBase64Url(input) {
+        if (input.trim() === '') {
+            return (0, neverthrow_1.err)({
+                code: 'INVALID_BASE64URL_CHARACTERS',
+                message: 'Invalid base64url: empty input',
+            });
+        }
+        if (input.includes('=')) {
+            return (0, neverthrow_1.err)({
+                code: 'INVALID_BASE64URL_PADDING',
+                message: 'Invalid base64url: padding is not allowed',
+            });
+        }
+        const base64UrlRe = /^[A-Za-z0-9_-]+$/;
+        if (!base64UrlRe.test(input)) {
+            return (0, neverthrow_1.err)({
+                code: 'INVALID_BASE64URL_CHARACTERS',
+                message: 'Invalid base64url: invalid characters',
+            });
+        }
+        try {
+            const decoded = node_buffer_1.Buffer.from(input, 'base64url');
+            if (decoded.toString('base64url') !== input) {
+                return (0, neverthrow_1.err)({
+                    code: 'INVALID_BASE64URL_CHARACTERS',
+                    message: 'Invalid base64url: non-canonical encoding',
+                });
+            }
+            return (0, neverthrow_1.ok)(new Uint8Array(decoded));
+        }
+        catch (e) {
+            return (0, neverthrow_1.err)({
+                code: 'INVALID_BASE64URL_CHARACTERS',
+                message: `Invalid base64url: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+    }
+}
+exports.NodeBase64UrlV2 = NodeBase64UrlV2;

package/dist/v2/infra/local/fs/index.js

@@ -38,9 +38,14 @@ const fs = __importStar(require("fs/promises"));
 const fsCb = __importStar(require("fs"));
 const fs_1 = require("fs");
 const neverthrow_1 = require("neverthrow");
+function nodeErrorCode(e) {
+    if (typeof e !== 'object' || e === null)
+        return undefined;
+    const code = e.code;
+    return typeof code === 'string' ? code : undefined;
+}
 function mapFsError(e, filePath) {
-    const any = e;
-    const code = any?.code;
+    const code = nodeErrorCode(e);
     if (code === 'ENOENT')
         return { code: 'FS_NOT_FOUND', message: `Not found: ${filePath}` };
     if (code === 'EEXIST')
@@ -130,8 +135,7 @@ class NodeFileSystemV2 {
                 await dirHandle.close();
             }
         })(), (e) => {
-            const any = e;
-            const code = any?.code;
+            const code = nodeErrorCode(e);
             if (code === 'EINVAL' || code === 'ENOTSUP') {
                 return { code: 'FS_UNSUPPORTED', message: `Directory fsync unsupported for: ${dirPath}` };
             }

package/dist/v2/infra/local/keyring/index.d.ts

@@ -2,10 +2,14 @@ import type { ResultAsync } from 'neverthrow';
 import type { DataDirPortV2 } from '../../../ports/data-dir.port.js';
 import type { FileSystemPortV2 } from '../../../ports/fs.port.js';
 import type { KeyringError, KeyringPortV2, KeyringV1 } from '../../../ports/keyring.port.js';
+import type { Base64UrlPortV2 } from '../../../ports/base64url.port.js';
+import type { RandomEntropyPortV2 } from '../../../ports/random-entropy.port.js';
 export declare class LocalKeyringV2 implements KeyringPortV2 {
     private readonly dataDir;
     private readonly fs;
-    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2);
+    private readonly base64url;
+    private readonly entropy;
+    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, base64url: Base64UrlPortV2, entropy: RandomEntropyPortV2);
     loadOrCreate(): ResultAsync<KeyringV1, KeyringError>;
     rotate(): ResultAsync<KeyringV1, KeyringError>;
     private createAndPersistFresh;