kernl 0.1.1

package/dist/serde/thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../../src/serde/thread.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;GAIG;AAEH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAG,KAAc,CAAC;AAQrD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;iBActB,CAAC;AAEH,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,GAAG;IAC7D,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC,CAAC;AAkHF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8B3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/serde/thread.js

@@ -0,0 +1,158 @@
+import { z } from "zod";
+import * as events from "../types/thread";
+/**
+ * Utilities and schemas for serializing the run-state so that it can be paused / resumed later.
+ *
+ * (TODO): should be able to define this as a codec for the ThreadState schema
+ */
+/**
+ * The schema version of the serialized run state. This is used to ensure that the serialized
+ * run state is compatible with the current version of the SDK.
+ * If anything in this schema changes, the version will have to be incremented.
+ */
+export const CURRENT_SCHEMA_VERSION = "1.0";
+const $schemaVersion = z.literal(CURRENT_SCHEMA_VERSION);
+const serializedAgentSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+});
+const serializedSpanBase = z.object({
+    object: z.literal("trace.span"),
+    id: z.string(),
+    trace_id: z.string(),
+    parent_id: z.string().nullable(),
+    started_at: z.string().nullable(),
+    ended_at: z.string().nullable(),
+    error: z
+        .object({
+        message: z.string(),
+        data: z.record(z.string(), z.any()).optional(),
+    })
+        .nullable(),
+    span_data: z.record(z.string(), z.any()),
+});
+const SerializedSpan = serializedSpanBase.extend({
+    previous_span: z.lazy(() => SerializedSpan).optional(),
+});
+const usageSchema = z.object({
+    requests: z.number(),
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    totalTokens: z.number(),
+});
+const modelResponseSchema = z.object({
+    usage: usageSchema,
+    events: z.array(events.ThreadEvent),
+    responseId: z.string().optional(),
+    providerData: z.record(z.string(), z.any()).optional(),
+});
+const itemSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("message"),
+        rawItem: events.AssistantMessage,
+        agent: serializedAgentSchema,
+    }),
+    z.object({
+        kind: z.literal("tool-call"),
+        // rawItem: events.ToolCall.or(events.HostedToolCall),
+        rawItem: events.ToolCall,
+        agent: serializedAgentSchema,
+    }),
+    z.object({
+        kind: z.literal("tool-result"),
+        rawItem: events.ToolResultEvent,
+        agent: serializedAgentSchema,
+        output: z.string(),
+    }),
+    z.object({
+        kind: z.literal("reasoning"),
+        rawItem: events.Reasoning,
+        agent: serializedAgentSchema,
+    }),
+]);
+const serializedTraceSchema = z.object({
+    object: z.literal("trace"),
+    id: z.string(),
+    workflow_name: z.string(),
+    group_id: z.string().nullable(),
+    metadata: z.record(z.string(), z.any()),
+});
+const serializedProcessedResponseSchema = z.object({
+    newItems: z.array(itemSchema),
+    toolsUsed: z.array(z.string()),
+    functions: z.array(z.object({
+        toolCall: z.any(),
+        tool: z.any(),
+    })),
+    mcpApprovalRequests: z
+        .array(z.object({
+        requestItem: z.object({
+            // protocol.HostedToolCallItem
+            rawItem: z.object({
+                type: z.literal("hosted_tool_call"),
+                name: z.string(),
+                arguments: z.string().optional(),
+                status: z.string().optional(),
+                output: z.string().optional(),
+                // this always exists but marked as optional for early version compatibility; when releasing 1.0, we can remove the nullable and optional
+                providerData: z.record(z.string(), z.any()).nullable().optional(),
+            }),
+        }),
+        // HostedMCPTool
+        mcpTool: z.object({
+            type: z.literal("hosted_tool"),
+            name: z.literal("hosted_mcp"),
+            providerData: z.record(z.string(), z.any()),
+        }),
+    }))
+        .optional(),
+});
+const guardrailFunctionOutputSchema = z.object({
+    tripwireTriggered: z.boolean(),
+    outputInfo: z.any(),
+});
+const inputGuardrailResultSchema = z.object({
+    guardrail: z.object({
+        type: z.literal("input"),
+        name: z.string(),
+    }),
+    output: guardrailFunctionOutputSchema,
+});
+const outputGuardrailResultSchema = z.object({
+    guardrail: z.object({
+        type: z.literal("output"),
+        name: z.string(),
+    }),
+    agentOutput: z.any(),
+    agent: serializedAgentSchema,
+    output: guardrailFunctionOutputSchema,
+});
+// (TODO): define z.codec
+export const SerializedThread = z.object({
+    $schemaVersion,
+    currentTurn: z.number(),
+    currentAgent: serializedAgentSchema, // (TODO): in our case we probably don't need to serialize the whole agent - an ID would suffice
+    originalInput: z.string().or(z.array(events.ThreadEvent)),
+    modelResponses: z.array(modelResponseSchema),
+    context: z.object({
+        usage: usageSchema, // (TODO): move to stats
+        // (TODO): belongs elsewhere
+        approvals: z.record(z.string(), z.object({
+            approved: z.array(z.string()).or(z.boolean()),
+            rejected: z.array(z.string()).or(z.boolean()),
+        })),
+        context: z.record(z.string(), z.any()),
+    }),
+    toolUseTracker: z.record(z.string(), z.array(z.string())),
+    maxTurns: z.number(),
+    currentAgentSpan: SerializedSpan.nullable().optional(),
+    noActiveAgentRun: z.boolean(),
+    inputGuardrailResults: z.array(inputGuardrailResultSchema),
+    outputGuardrailResults: z.array(outputGuardrailResultSchema),
+    // (TODO): currentStep: nextStepSchema.optional(),
+    lastModelResponse: modelResponseSchema.optional(),
+    generatedItems: z.array(itemSchema),
+    lastProcessedResponse: serializedProcessedResponseSchema.optional(),
+    currentTurnPersistedItemCount: z.number().int().min(0).optional(),
+    trace: serializedTraceSchema.nullable(),
+});

package/dist/serde/tool.d.ts

@@ -0,0 +1,36 @@
+import type { ToolInputParameters } from "../tool/types";
+/**
+ * Serialized function tool for model requests
+ */
+export type SerializedFunctionTool = {
+    /**
+     * The type of the tool.
+     */
+    type: "function";
+    /**
+     * The name of the tool.
+     */
+    name?: string;
+    /**
+     * The description of the tool that helps the model to understand when to use the tool
+     */
+    description: string;
+    /**
+     * A JSON schema describing the parameters of the tool.
+     */
+    parameters: ToolInputParameters;
+};
+/**
+ * Serialized hosted tool for model requests
+ */
+export type SerializedHostedTool = {
+    type: "hosted-tool";
+    id: string;
+    name?: string;
+    providerData?: Record<string, any>;
+};
+/**
+ * Union of all serialized tool types
+ */
+export type SerializedTool = SerializedFunctionTool | SerializedHostedTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/serde/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/serde/tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC;;OAEG;IACH,IAAI,EAAE,UAAU,CAAC;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,mBAAmB,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,aAAa,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACpC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,sBAAsB,GAAG,oBAAoB,CAAC"}

package/dist/serde/tool.js

@@ -0,0 +1 @@
+export {};

package/dist/session.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":""}

package/dist/session.js

@@ -0,0 +1 @@
+"use strict";

package/dist/task.d.ts

@@ -0,0 +1,87 @@
+import type { Agent } from "./agent";
+import type { Context, UnknownContext } from "./context";
+import type { Thread } from "./thread";
+/**
+ * A Task represents a unit of work scheduled by the kernl.
+ * Analogous to task_struct in the Linux kernel.
+ */
+export declare class Task<TContext = UnknownContext, TResult = unknown> {
+    pid: string;
+    instructions: string | ((context: Context<TContext>) => string);
+    state: TaskState;
+    owner: Agent<TContext>;
+    context: Context<TContext>;
+    /**
+     * Might want the ability to pick up a new thread of execution from a compressed task checkpoint instead of including
+     * all of the events from the old threads (which may no longer be useful if they completed with good artifacts + reasoning / action summaries).
+     * At that point its really more about tracing.
+     */
+    threads: Thread<TContext>[];
+    current: Thread<TContext> | null;
+    result: TResult | null;
+    constructor(init: {
+        pid: string;
+        instructions: string | ((context: Context<TContext>) => string);
+        state: TaskState;
+        owner: Agent<TContext>;
+        context: Context<TContext>;
+    });
+}
+/**
+ * The various states that a task may be in.
+ */
+export declare enum TaskState {
+    /**
+     * Task is either:
+     * - Currently executing
+     * - In run queue waiting to be scheduled (might want to differentiate between running + queued here)
+     */
+    RUNNING = "running",
+    /**
+     * Task is sleeping/blocked, waiting for a condition.
+     * Can be woken up by:
+     * - The condition being met (e.g., approval granted)
+     * - A signal (e.g., user cancellation)
+     *
+     * Examples:
+     * - Waiting for tool approval
+     * - Waiting for user input
+     * - Sleeping on a timer
+     */
+    INTERRUPTIBLE = "interruptible",
+    /**
+     * Task is sleeping/blocked and CANNOT be interrupted by signals.
+     * Only wakes when the condition is met.
+     *
+     * Examples:
+     * - Waiting for critical I/O (model API call)
+     * - Waiting for resource that MUST complete
+     *
+     * Use sparingly - these tasks can't be cancelled!
+     */
+    UNINTERRUPTIBLE = "uninterruptible",
+    /**
+     * Task has been stopped by a signal (SIGSTOP).
+     * Will remain stopped until explicitly continued (SIGCONT).
+     *
+     * Examples:
+     * - User explicitly paused the agent
+     * - Debugger attached
+     */
+    STOPPED = "stopped",
+    /**
+     * Task has finished execution but hasn't been cleaned up yet.
+     * Waiting for parent to read exit status (wait/waitpid).
+     *
+     * Examples:
+     * - Agent completed but result not yet retrieved
+     * - Child agent finished, parent needs to collect result
+     */
+    ZOMBIE = "zombie",
+    /**
+     * Task is being removed from the system.
+     * Final cleanup in progress, about to be fully deleted.
+     */
+    DEAD = "dead"
+}
+//# sourceMappingURL=task.d.ts.map

package/dist/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../src/task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;GAGG;AACH,qBAAa,IAAI,CAAC,QAAQ,GAAG,cAAc,EAAE,OAAO,GAAG,OAAO;IAC5D,GAAG,EAAE,MAAM,CAAoD;IAG/D,YAAY,EACR,MAAM,GACN,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,CAA4B;IAExE,KAAK,EAAE,SAAS,CAAiC;IACjD,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAA2C;IAEjE,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAA0D;IAIpF;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,CAA6C;IACxE,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAyC;IACzE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAgC;gBAQ1C,IAAI,EAAE;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,YAAY,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,CAAC;QAChE,KAAK,EAAE,SAAS,CAAC;QACjB,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;QACvB,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;KAC5B;CAUF;AAED;;GAEG;AACH,oBAAY,SAAS;IACnB;;;;OAIG;IACH,OAAO,YAAY;IAEnB;;;;;;;;;;OAUG;IACH,aAAa,kBAAkB;IAE/B;;;;;;;;;OASG;IACH,eAAe,oBAAoB;IAEnC;;;;;;;OAOG;IACH,OAAO,YAAY;IAEnB;;;;;;;OAOG;IACH,MAAM,WAAW;IAEjB;;;OAGG;IACH,IAAI,SAAS;CACd"}

package/dist/task.js

@@ -0,0 +1,97 @@
+/**
+ * A Task represents a unit of work scheduled by the kernl.
+ * Analogous to task_struct in the Linux kernel.
+ */
+export class Task {
+    pid;
+    // tgid: string | null; /* task groupid */
+    // prio: TaskPriority;
+    instructions;
+    // sched: TaskSched; /* scheduling (timers, timeouts, deadlines) */
+    state;
+    owner;
+    context;
+    // cred: Credentials; /* Effective (overridable) subjective task credentials (COW): */
+    // realcred: Credentials; /* Objective and real subjective task credentials (COW): */
+    /**
+     * Might want the ability to pick up a new thread of execution from a compressed task checkpoint instead of including
+     * all of the events from the old threads (which may no longer be useful if they completed with good artifacts + reasoning / action summaries).
+     * At that point its really more about tracing.
+     */
+    threads;
+    current;
+    result;
+    // checkpoints: TaskCheckpoint<TContext>[]; /* checkpoints for resuming execution */
+    // TODO: Deferred fields for later implementation
+    // tgid: string;              // Thread group ID
+    // limits: TaskLimits;        // Resource limits (max ticks, tokens, timeout)
+    // nsproxy: NamespaceProxy;   // Namespace isolation
+    constructor(init) {
+        this.pid = init.pid;
+        this.instructions = init.instructions;
+        this.state = init.state;
+        this.owner = init.owner;
+        this.context = init.context;
+        this.threads = [];
+        this.current = null;
+        this.result = null;
+    }
+}
+/**
+ * The various states that a task may be in.
+ */
+export var TaskState;
+(function (TaskState) {
+    /**
+     * Task is either:
+     * - Currently executing
+     * - In run queue waiting to be scheduled (might want to differentiate between running + queued here)
+     */
+    TaskState["RUNNING"] = "running";
+    /**
+     * Task is sleeping/blocked, waiting for a condition.
+     * Can be woken up by:
+     * - The condition being met (e.g., approval granted)
+     * - A signal (e.g., user cancellation)
+     *
+     * Examples:
+     * - Waiting for tool approval
+     * - Waiting for user input
+     * - Sleeping on a timer
+     */
+    TaskState["INTERRUPTIBLE"] = "interruptible";
+    /**
+     * Task is sleeping/blocked and CANNOT be interrupted by signals.
+     * Only wakes when the condition is met.
+     *
+     * Examples:
+     * - Waiting for critical I/O (model API call)
+     * - Waiting for resource that MUST complete
+     *
+     * Use sparingly - these tasks can't be cancelled!
+     */
+    TaskState["UNINTERRUPTIBLE"] = "uninterruptible";
+    /**
+     * Task has been stopped by a signal (SIGSTOP).
+     * Will remain stopped until explicitly continued (SIGCONT).
+     *
+     * Examples:
+     * - User explicitly paused the agent
+     * - Debugger attached
+     */
+    TaskState["STOPPED"] = "stopped";
+    /**
+     * Task has finished execution but hasn't been cleaned up yet.
+     * Waiting for parent to read exit status (wait/waitpid).
+     *
+     * Examples:
+     * - Agent completed but result not yet retrieved
+     * - Child agent finished, parent needs to collect result
+     */
+    TaskState["ZOMBIE"] = "zombie";
+    /**
+     * Task is being removed from the system.
+     * Final cleanup in progress, about to be fully deleted.
+     */
+    TaskState["DEAD"] = "dead";
+})(TaskState || (TaskState = {}));

package/dist/thread/__tests__/mock.d.ts

@@ -0,0 +1,28 @@
+import { LanguageModel, LanguageModelRequest, LanguageModelResponse } from "@kernl/protocol";
+import type { ThreadStreamEvent } from "../../types/thread";
+/**
+ * A mock language model that echoes the user input back as an assistant message.
+ * Useful for testing the execution flow without calling a real LLM.
+ *
+ * (TODO): Support tool calls for testing.
+ */
+export declare class MockLanguageModel implements LanguageModel {
+    readonly spec: "1.0";
+    readonly provider = "mock";
+    readonly modelId = "mock-model";
+    generate(request: LanguageModelRequest): Promise<LanguageModelResponse>;
+    stream(request: LanguageModelRequest): AsyncIterable<ThreadStreamEvent>;
+    /**
+     * Extract text from the input (LanguageModelItem[])
+     */
+    private extractUserText;
+    /**
+     * Simple token counter (fake approximation)
+     */
+    private countTokens;
+    /**
+     * Generate a simple ID for messages
+     */
+    private generateId;
+}
+//# sourceMappingURL=mock.d.ts.map

package/dist/thread/__tests__/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../../src/thread/__tests__/mock.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EAGtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,aAAa;IACrD,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,UAAU;IAC3B,QAAQ,CAAC,OAAO,gBAAgB;IAE1B,QAAQ,CACZ,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAgC1B,MAAM,CACX,OAAO,EAAE,oBAAoB,GAC5B,aAAa,CAAC,iBAAiB,CAAC;IAKnC;;OAEG;IACH,OAAO,CAAC,eAAe;IAgBvB;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,UAAU;CAGnB"}

package/dist/thread/__tests__/mock.js

@@ -0,0 +1,74 @@
+/**
+ * A mock language model that echoes the user input back as an assistant message.
+ * Useful for testing the execution flow without calling a real LLM.
+ *
+ * (TODO): Support tool calls for testing.
+ */
+export class MockLanguageModel {
+    spec = "1.0";
+    provider = "mock";
+    modelId = "mock-model";
+    async generate(request) {
+        // Extract user message text from input
+        const userText = this.extractUserText(request.input);
+        // Create assistant message that echoes the input
+        const content = [
+            {
+                kind: "message",
+                id: this.generateId(),
+                role: "assistant",
+                content: [
+                    {
+                        kind: "text",
+                        text: userText,
+                    },
+                ],
+            },
+        ];
+        // Return with fake usage stats
+        return {
+            content,
+            finishReason: "stop",
+            usage: {
+                inputTokens: this.countTokens(userText),
+                outputTokens: this.countTokens(userText),
+                totalTokens: this.countTokens(userText) * 2,
+            },
+            warnings: [],
+        };
+    }
+    async *stream(request) {
+        // TODO: Implement streaming (not needed for hello world)
+        throw new Error("MockLanguageModel.stream() not implemented yet");
+    }
+    /**
+     * Extract text from the input (LanguageModelItem[])
+     */
+    extractUserText(input) {
+        // Extract text from LanguageModelItem array
+        const text = [];
+        for (const item of input) {
+            if (item.kind === "message" && item.role === "user") {
+                for (const part of item.content) {
+                    if (part.kind === "text") {
+                        text.push(part.text);
+                    }
+                }
+            }
+        }
+        return text.join(" ");
+    }
+    /**
+     * Simple token counter (fake approximation)
+     */
+    countTokens(text) {
+        // Rough approximation: 1 token H 4 characters
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Generate a simple ID for messages
+     */
+    generateId() {
+        return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+}

package/dist/thread/__tests__/thread.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=thread.test.d.ts.map

package/dist/thread/__tests__/thread.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread.test.d.ts","sourceRoot":"","sources":["../../../src/thread/__tests__/thread.test.ts"],"names":[],"mappings":""}