@jinn-network/client 0.1.2 → 0.1.3-canary.2d6b2676

package/dist/types/task-document.js

@@ -0,0 +1,69 @@
+/**
+ * task.v1 — canonical signed Task document.
+ *
+ * This is the IPFS-addressed, signed document posted through the deployed
+ * router compatibility surface. `solverType` is the protocol join key; `spec`
+ * is the SolverType-specific payload.
+ */
+import { z } from 'zod';
+import { WindowSchema } from './window.js';
+const HexStringSchema = z
+    .string()
+    .regex(/^0x[0-9a-fA-F]*$/, 'must be a 0x-prefixed hex string');
+const SignatureSchema = z.object({
+    algo: z.literal('secp256k1'),
+    signer: HexStringSchema,
+    hash: HexStringSchema,
+    sig: HexStringSchema,
+});
+const CreatorSchema = z.object({
+    safeAddress: HexStringSchema,
+    agentEoa: HexStringSchema,
+});
+const NoLegacyKindSchema = z.record(z.unknown()).superRefine((spec, ctx) => {
+    if (Object.prototype.hasOwnProperty.call(spec, 'kind')) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'spec.kind is retired; use top-level solverType',
+            path: ['kind'],
+        });
+    }
+});
+const TaskV1Fields = {
+    schemaVersion: z.literal('task.v1'),
+    id: z.string().min(1),
+    solverType: z.string().min(1),
+    role: z.enum(['restoration', 'evaluation']).default('restoration'),
+    description: z.string().min(1),
+    window: WindowSchema,
+    spec: NoLegacyKindSchema,
+    eligibility: z.record(z.unknown()),
+    creator: CreatorSchema,
+    createdAt: z.number().int(),
+};
+function rejectTopLevelKind(schema) {
+    return schema.passthrough().superRefine((task, ctx) => {
+        if (Object.prototype.hasOwnProperty.call(task, 'kind')) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'kind is retired; use top-level solverType',
+                path: ['kind'],
+            });
+        }
+    }).transform((task) => {
+        const { kind: _kind, ...canonical } = task;
+        return canonical;
+    });
+}
+export const TaskV1Schema = rejectTopLevelKind(z.object(TaskV1Fields));
+export const SignedTaskV1Schema = rejectTopLevelKind(z.object({
+    ...TaskV1Fields,
+    signature: SignatureSchema,
+}));
+export function parseTaskV1(input) {
+    return TaskV1Schema.parse(input);
+}
+export function parseSignedTaskV1(input) {
+    return SignedTaskV1Schema.parse(input);
+}
+//# sourceMappingURL=task-document.js.map

package/dist/types/task-document.js.map

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

package/dist/types/task.d.ts

@@ -0,0 +1,455 @@
+import { z } from 'zod';
+import { WindowSchema, type Window } from './window.js';
+import { type SignedTaskV1 } from './task-document.js';
+export type RequestId = string;
+export { WindowSchema, type Window };
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    solverType: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodEnum<["restoration", "evaluation"]>>;
+    attemptId: z.ZodOptional<z.ZodString>;
+    attemptNumber: z.ZodOptional<z.ZodNumber>;
+    restorationRequestId: z.ZodOptional<z.ZodString>;
+    window: z.ZodOptional<z.ZodObject<{
+        startTs: z.ZodNumber;
+        endTs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        startTs: number;
+        endTs: number;
+    }, {
+        startTs: number;
+        endTs: number;
+    }>>;
+    spec: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    eligibility: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    signedTask: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        signature: z.ZodObject<{
+            algo: z.ZodLiteral<"secp256k1">;
+            signer: z.ZodString;
+            hash: z.ZodString;
+            sig: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }>;
+        schemaVersion: z.ZodLiteral<"task.v1">;
+        id: z.ZodString;
+        solverType: z.ZodString;
+        role: z.ZodDefault<z.ZodEnum<["restoration", "evaluation"]>>;
+        description: z.ZodString;
+        window: z.ZodObject<{
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startTs: number;
+            endTs: number;
+        }, {
+            startTs: number;
+            endTs: number;
+        }>;
+        spec: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+        eligibility: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        creator: z.ZodObject<{
+            safeAddress: z.ZodString;
+            agentEoa: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+            agentEoa: string;
+        }, {
+            safeAddress: string;
+            agentEoa: string;
+        }>;
+        createdAt: z.ZodNumber;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        signature: z.ZodObject<{
+            algo: z.ZodLiteral<"secp256k1">;
+            signer: z.ZodString;
+            hash: z.ZodString;
+            sig: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }>;
+        schemaVersion: z.ZodLiteral<"task.v1">;
+        id: z.ZodString;
+        solverType: z.ZodString;
+        role: z.ZodDefault<z.ZodEnum<["restoration", "evaluation"]>>;
+        description: z.ZodString;
+        window: z.ZodObject<{
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startTs: number;
+            endTs: number;
+        }, {
+            startTs: number;
+            endTs: number;
+        }>;
+        spec: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+        eligibility: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        creator: z.ZodObject<{
+            safeAddress: z.ZodString;
+            agentEoa: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+            agentEoa: string;
+        }, {
+            safeAddress: string;
+            agentEoa: string;
+        }>;
+        createdAt: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        signature: z.ZodObject<{
+            algo: z.ZodLiteral<"secp256k1">;
+            signer: z.ZodString;
+            hash: z.ZodString;
+            sig: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }>;
+        schemaVersion: z.ZodLiteral<"task.v1">;
+        id: z.ZodString;
+        solverType: z.ZodString;
+        role: z.ZodDefault<z.ZodEnum<["restoration", "evaluation"]>>;
+        description: z.ZodString;
+        window: z.ZodObject<{
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startTs: number;
+            endTs: number;
+        }, {
+            startTs: number;
+            endTs: number;
+        }>;
+        spec: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+        eligibility: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        creator: z.ZodObject<{
+            safeAddress: z.ZodString;
+            agentEoa: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+            agentEoa: string;
+        }, {
+            safeAddress: string;
+            agentEoa: string;
+        }>;
+        createdAt: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        signature: z.ZodObject<{
+            algo: z.ZodLiteral<"secp256k1">;
+            signer: z.ZodString;
+            hash: z.ZodString;
+            sig: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }>;
+        schemaVersion: z.ZodLiteral<"task.v1">;
+        id: z.ZodString;
+        solverType: z.ZodString;
+        role: z.ZodDefault<z.ZodEnum<["restoration", "evaluation"]>>;
+        description: z.ZodString;
+        window: z.ZodObject<{
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startTs: number;
+            endTs: number;
+        }, {
+            startTs: number;
+            endTs: number;
+        }>;
+        spec: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+        eligibility: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        creator: z.ZodObject<{
+            safeAddress: z.ZodString;
+            agentEoa: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+            agentEoa: string;
+        }, {
+            safeAddress: string;
+            agentEoa: string;
+        }>;
+        createdAt: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        signature: z.ZodObject<{
+            algo: z.ZodLiteral<"secp256k1">;
+            signer: z.ZodString;
+            hash: z.ZodString;
+            sig: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }>;
+        schemaVersion: z.ZodLiteral<"task.v1">;
+        id: z.ZodString;
+        solverType: z.ZodString;
+        role: z.ZodDefault<z.ZodEnum<["restoration", "evaluation"]>>;
+        description: z.ZodString;
+        window: z.ZodObject<{
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startTs: number;
+            endTs: number;
+        }, {
+            startTs: number;
+            endTs: number;
+        }>;
+        spec: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+        eligibility: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        creator: z.ZodObject<{
+            safeAddress: z.ZodString;
+            agentEoa: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+            agentEoa: string;
+        }, {
+            safeAddress: string;
+            agentEoa: string;
+        }>;
+        createdAt: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">>, {
+        id: string;
+        signature: {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        };
+        schemaVersion: "task.v1";
+        solverType: string;
+        role: "restoration" | "evaluation";
+        description: string;
+        window: {
+            startTs: number;
+            endTs: number;
+        };
+        spec: Record<string, unknown>;
+        eligibility: Record<string, unknown>;
+        creator: {
+            safeAddress: string;
+            agentEoa: string;
+        };
+        createdAt: number;
+    }, z.objectInputType<{
+        signature: z.ZodObject<{
+            algo: z.ZodLiteral<"secp256k1">;
+            signer: z.ZodString;
+            hash: z.ZodString;
+            sig: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }>;
+        schemaVersion: z.ZodLiteral<"task.v1">;
+        id: z.ZodString;
+        solverType: z.ZodString;
+        role: z.ZodDefault<z.ZodEnum<["restoration", "evaluation"]>>;
+        description: z.ZodString;
+        window: z.ZodObject<{
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startTs: number;
+            endTs: number;
+        }, {
+            startTs: number;
+            endTs: number;
+        }>;
+        spec: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+        eligibility: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        creator: z.ZodObject<{
+            safeAddress: z.ZodString;
+            agentEoa: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+            agentEoa: string;
+        }, {
+            safeAddress: string;
+            agentEoa: string;
+        }>;
+        createdAt: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | undefined;
+    solverType?: string | undefined;
+    role?: "restoration" | "evaluation" | undefined;
+    description?: string | undefined;
+    window?: {
+        startTs: number;
+        endTs: number;
+    } | undefined;
+    spec?: Record<string, unknown> | undefined;
+    eligibility?: Record<string, unknown> | undefined;
+    context?: Record<string, unknown> | undefined;
+    attemptId?: string | undefined;
+    attemptNumber?: number | undefined;
+    restorationRequestId?: string | undefined;
+    signedTask?: {
+        id: string;
+        signature: {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        };
+        schemaVersion: "task.v1";
+        solverType: string;
+        role: "restoration" | "evaluation";
+        description: string;
+        window: {
+            startTs: number;
+            endTs: number;
+        };
+        spec: Record<string, unknown>;
+        eligibility: Record<string, unknown>;
+        creator: {
+            safeAddress: string;
+            agentEoa: string;
+        };
+        createdAt: number;
+    } | undefined;
+}, {
+    id?: string | undefined;
+    solverType?: string | undefined;
+    role?: "restoration" | "evaluation" | undefined;
+    description?: string | undefined;
+    window?: {
+        startTs: number;
+        endTs: number;
+    } | undefined;
+    spec?: Record<string, unknown> | undefined;
+    eligibility?: Record<string, unknown> | undefined;
+    context?: Record<string, unknown> | undefined;
+    attemptId?: string | undefined;
+    attemptNumber?: number | undefined;
+    restorationRequestId?: string | undefined;
+    signedTask?: z.objectInputType<{
+        signature: z.ZodObject<{
+            algo: z.ZodLiteral<"secp256k1">;
+            signer: z.ZodString;
+            hash: z.ZodString;
+            sig: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }, {
+            hash: string;
+            algo: "secp256k1";
+            signer: string;
+            sig: string;
+        }>;
+        schemaVersion: z.ZodLiteral<"task.v1">;
+        id: z.ZodString;
+        solverType: z.ZodString;
+        role: z.ZodDefault<z.ZodEnum<["restoration", "evaluation"]>>;
+        description: z.ZodString;
+        window: z.ZodObject<{
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            startTs: number;
+            endTs: number;
+        }, {
+            startTs: number;
+            endTs: number;
+        }>;
+        spec: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+        eligibility: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        creator: z.ZodObject<{
+            safeAddress: z.ZodString;
+            agentEoa: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            safeAddress: string;
+            agentEoa: string;
+        }, {
+            safeAddress: string;
+            agentEoa: string;
+        }>;
+        createdAt: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>;
+export interface Task {
+    id: string;
+    description: string;
+    context?: Record<string, unknown>;
+    solverType?: string;
+    role?: 'restoration' | 'evaluation';
+    attemptId?: string;
+    attemptNumber?: number;
+    restorationRequestId?: string;
+    window?: Window;
+    spec?: Record<string, unknown>;
+    eligibility?: Record<string, unknown>;
+    signedTask?: SignedTaskV1;
+}
+export declare function parseTask(input: unknown): Task;
+export interface TaskRequest {
+    requestId: RequestId;
+    task: Task;
+    payment?: string;
+    timeout?: number;
+    taskCid?: string;
+    onchainCreationTx?: `0x${string}`;
+    onchainCreationBlock?: number;
+}
+export interface TaskResult {
+    data: string;
+    artifacts?: string[];
+}
+export interface DeliveredResult {
+    requestId: RequestId;
+    task: Task;
+    result: TaskResult;
+    deliveryMechAddress: string;
+}

package/dist/types/task.js

@@ -0,0 +1,58 @@
+/**
+ * Runtime shape of a Task — wraps SignedTaskV1 plus
+ * runtime fields (attempt number, role, etc.).
+ */
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { WindowSchema } from './window.js';
+import { SignedTaskV1Schema } from './task-document.js';
+// ── Window (re-exported for backwards compat) ─────────────────────────────────
+export { WindowSchema };
+// ── Task schema ─────────────────────────────────────────────────────
+export const TaskSchema = z.object({
+    id: z.string().optional(),
+    description: z.string().min(1).optional(),
+    context: z.record(z.unknown()).optional(),
+    solverType: z.string().optional(),
+    role: z.enum(['restoration', 'evaluation']).optional(),
+    attemptId: z.string().optional(),
+    attemptNumber: z.number().int().optional(),
+    restorationRequestId: z.string().optional(),
+    // §3 — optional lifecycle window
+    window: WindowSchema.optional(),
+    // §3 — typed task payload; dispatcher is top-level `solverType`.
+    spec: z.record(z.unknown()).optional(),
+    // §3 — pre-claim and post-hoc qualifying rules; shape governed by solverType
+    eligibility: z.record(z.unknown()).optional(),
+    signedTask: SignedTaskV1Schema.optional(),
+});
+export function parseTask(input) {
+    const parsed = TaskSchema.parse(input);
+    const signedTask = parsed.signedTask;
+    const signedRuntime = signedTask;
+    const description = parsed.description ?? signedTask?.description;
+    if (!description) {
+        throw new Error('Task requires description (loose field or signedTask.description)');
+    }
+    const parsedSpec = parsed.spec;
+    if (parsedSpec && Object.prototype.hasOwnProperty.call(parsedSpec, 'kind')) {
+        throw new Error('Task spec.kind is retired; use top-level solverType');
+    }
+    const solverType = parsed.solverType ?? signedTask?.solverType;
+    const spec = parsedSpec ?? signedTask?.spec;
+    return {
+        id: parsed.id ?? signedTask?.id ?? randomUUID(),
+        description,
+        context: parsed.context ?? signedRuntime?.context,
+        solverType,
+        role: parsed.role ?? signedTask?.role,
+        attemptId: parsed.attemptId ?? signedRuntime?.attemptId,
+        attemptNumber: parsed.attemptNumber ?? signedRuntime?.attemptNumber,
+        restorationRequestId: parsed.restorationRequestId ?? signedRuntime?.restorationRequestId,
+        window: parsed.window ?? signedTask?.window,
+        spec,
+        eligibility: parsed.eligibility ?? signedTask?.eligibility,
+        signedTask,
+    };
+}
+//# sourceMappingURL=task.js.map

package/dist/types/task.js.map

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

package/dist/types/window.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const WindowSchema: z.ZodObject<{
+    startTs: z.ZodNumber;
+    endTs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    startTs: number;
+    endTs: number;
+}, {
+    startTs: number;
+    endTs: number;
+}>;
+export type Window = z.infer<typeof WindowSchema>;

package/dist/types/window.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const WindowSchema = z.object({
+    startTs: z.number().int(),
+    endTs: z.number().int(),
+});
+//# sourceMappingURL=window.js.map

package/dist/types/window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"window.js","sourceRoot":"","sources":["../../src/types/window.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACzB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;CACxB,CAAC,CAAC"}

package/dist/util/path-safety.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Path containment helpers — defence against `..` traversal and
+ * absolute-path escapes when joining attacker-influenced relative
+ * paths into a daemon-owned base directory.
+ *
+ * Manifest-bearing packages honour the convention that manifest entries are
+ * package-relative paths; this helper enforces that contract at runtime as
+ * belt-and-suspenders for the schema regex.
+ */
+/**
+ * Returns true iff `candidate` resolves to a path strictly inside
+ * `baseDir`. Rejects:
+ *   - dotdot traversal (`./../etc/passwd`)
+ *   - absolute paths that point outside (`/etc/passwd`)
+ *   - paths equal to `baseDir` itself (the base is a directory, not a
+ *     file we'd expect to import)
+ *
+ * Symlink escapes are NOT resolved here — callers that hand untrusted
+ * symlink-bearing trees should additionally `fs.realpath` both sides.
+ */
+export declare function isInsidePackageDir(baseDir: string, candidate: string): boolean;

package/dist/util/path-safety.js

@@ -0,0 +1,28 @@
+/**
+ * Path containment helpers — defence against `..` traversal and
+ * absolute-path escapes when joining attacker-influenced relative
+ * paths into a daemon-owned base directory.
+ *
+ * Manifest-bearing packages honour the convention that manifest entries are
+ * package-relative paths; this helper enforces that contract at runtime as
+ * belt-and-suspenders for the schema regex.
+ */
+import { isAbsolute, relative, resolve } from 'node:path';
+/**
+ * Returns true iff `candidate` resolves to a path strictly inside
+ * `baseDir`. Rejects:
+ *   - dotdot traversal (`./../etc/passwd`)
+ *   - absolute paths that point outside (`/etc/passwd`)
+ *   - paths equal to `baseDir` itself (the base is a directory, not a
+ *     file we'd expect to import)
+ *
+ * Symlink escapes are NOT resolved here — callers that hand untrusted
+ * symlink-bearing trees should additionally `fs.realpath` both sides.
+ */
+export function isInsidePackageDir(baseDir, candidate) {
+    const base = resolve(baseDir);
+    const cand = resolve(candidate);
+    const rel = relative(base, cand);
+    return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+}
+//# sourceMappingURL=path-safety.js.map

package/dist/util/path-safety.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-safety.js","sourceRoot":"","sources":["../../src/util/path-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAe,EAAE,SAAiB;IACnE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACjC,OAAO,GAAG,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AACjE,CAAC"}

package/dist/util/redact-rpc-urls.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Strip URLs from arbitrary error messages before they hit logs / stdout.
+ * RPC endpoints often embed API keys; logging an `Error.message` verbatim leaks them.
+ */
+export declare function redactRpcUrls(input: unknown): string;