@nylorun/core 0.0.0-bootstrap → 0.1.1-beta

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+/** Machine-readable error raised by Harness-owned code. */
+export type HarnessErrorCode = "execution.invalid-state" | "execution.invalid-input" | "execution.incompatible" | "execution.record-failed" | "tool.unregistered" | "tool.invalid-binding" | "agent.build-failed" | "agent.lifecycle-sealed" | "context.invalid-item" | "context.invalid-item-type" | "context.invalid-order" | "context.invalid-reason" | "context.invalid-slot" | "interaction.invalid" | "interaction.missing-resume" | "interaction.uncorrelated-resume" | "input.invalid-content" | "output.invalid" | "output.invalid-schema" | "json.invalid-data" | "json.invalid-object" | "middleware.next-after-return" | "middleware.next-called-twice" | "middleware.request-mutators-revoked" | "model.candidate-missing" | "model.adapter-invalid-options" | "model.adapter-invalid-response" | "model.invalid-candidate" | "model.invalid-directive" | "model.unsupported-content" | "model.unsupported-output-schema" | "configuration.duplicate-tool-name" | "configuration.invalid" | "configuration.invalid-instructions" | "configuration.invalid-order" | "configuration.invalid-reason" | "configuration.invalid-slot" | "configuration.invalid-tools" | "configuration.model-selection-conflict" | "response.invalid-replacement" | "tool.invalid" | "tool.invalid-arguments" | "tool.invalid-output" | "tool.invalid-name" | "tool.invalid-schema" | "tool.invalid-tool-result";
+export type HarnessErrorDetails = Readonly<Record<string, string | number | boolean>>;
+export interface HarnessErrorOptions {
+    readonly cause?: unknown;
+    readonly details?: HarnessErrorDetails;
+}
+/**
+ * The sole error shape produced by Harness itself. Message text is explanatory;
+ * callers must branch on `code`.
+ */
+export declare class HarnessError extends Error {
+    readonly code: HarnessErrorCode;
+    readonly details: HarnessErrorDetails;
+    constructor(code: HarnessErrorCode, message: string, options?: HarnessErrorOptions);
+}
+export declare function isHarnessError(error: unknown): error is HarnessError;

package/dist/errors.js

@@ -0,0 +1,22 @@
+const errorBrand = Symbol.for("@nylorun/core/HarnessError");
+/**
+ * The sole error shape produced by Harness itself. Message text is explanatory;
+ * callers must branch on `code`.
+ */
+export class HarnessError extends Error {
+    code;
+    details;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "HarnessError";
+        Object.defineProperty(this, errorBrand, { value: true });
+        this.code = code;
+        this.details = Object.freeze({ ...(options.details ?? {}) });
+    }
+}
+export function isHarnessError(error) {
+    return (error instanceof HarnessError ||
+        (typeof error === "object" &&
+            error !== null &&
+            error[errorBrand] === true));
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./contracts.js";
+export type * from "./types/dynamics.js";
+export type * from "./types/middleware.js";
+export type * from "./types/tool.js";
+export type * from "./types/agent.js";
+export type * from "./types/observe.js";
+export type * from "./types/model.js";
+export type * from "./types/shared.js";
+export type * from "./types/manifest.js";
+export type * from "./types/transcript.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./contracts.js";

package/dist/types/agent.d.ts

@@ -0,0 +1,12 @@
+import type { AgentBinding } from "../definition/binding.js";
+import type { AgentManifest } from "./manifest.js";
+/** An agent definition composed with Agent(...).use(...). Optional `.build()` is a no-op facade. */
+export interface BuiltAgent<Info = unknown, Output = string> {
+    readonly id: string;
+    readonly name: string;
+    readonly manifest: AgentManifest;
+    /** Canonical SHA-256 of `manifest` — durable definition identity. */
+    readonly hash: string;
+    toJSON(): AgentManifest;
+    getBinding(): AgentBinding;
+}

package/dist/types/agent.js

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

package/dist/types/dynamics.d.ts

@@ -0,0 +1,53 @@
+import type { JsonValue } from "./shared.js";
+import type { PromptItem } from "./model.js";
+import type { MessageInput } from "./transcript.js";
+/** Closed-world patch applied before a model call. No `model` — Runtime owns resolution. */
+export type Patch = {
+    /** Switch capabilities declared in the manifest. */
+    readonly capabilities?: Readonly<Record<string, boolean>>;
+    /** Switch tools by name. */
+    readonly tools?: Readonly<Record<string, boolean>>;
+    /** Extra instructions for this model call only. */
+    readonly instructions?: readonly string[];
+    /** Write session state keys (merged into durable session state). */
+    readonly state?: Readonly<Record<string, JsonValue>>;
+    /** Refuse this model call; message returned to the host. */
+    readonly block?: string;
+    /**
+     * Capability-level shorthand: toggle only this capability.
+     * Normalized to `capabilities: { [id]: active }` at bind time.
+     */
+    readonly active?: boolean;
+};
+/** Decision applied after a model response, before tools/text take effect. */
+export type Decision = {
+    readonly text?: string;
+    readonly deny?: readonly {
+        readonly id: string;
+        readonly reason: string;
+    }[];
+    readonly approve?: readonly {
+        readonly id: string;
+        readonly prompt: string;
+    }[];
+    readonly retry?: string;
+    readonly block?: string;
+};
+export type BeforeModelCallFn<Info = unknown> = (args: {
+    readonly input?: MessageInput | string;
+    readonly info?: Info;
+    readonly state: Readonly<Record<string, JsonValue>>;
+    readonly messages: readonly PromptItem[];
+    readonly step: number;
+}) => Patch | Promise<Patch>;
+export type AfterModelCallFn<Info = unknown> = (args: {
+    readonly text?: string;
+    readonly toolCalls: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly args: JsonValue;
+    }[];
+}, ctx: {
+    readonly info?: Info;
+    readonly state: Readonly<Record<string, JsonValue>>;
+}) => Decision | Promise<Decision>;

package/dist/types/dynamics.js

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

package/dist/types/manifest.d.ts

@@ -0,0 +1,34 @@
+import type { ModelDirective } from "./model.js";
+import type { JsonObject } from "./shared.js";
+/** Published manifest schema version (no top-level model — Runtime-owned). */
+export type ManifestSchemaVersion = 2;
+export interface ManifestTool {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: JsonObject;
+    readonly outputSchema?: JsonObject;
+}
+export interface CapabilityManifest {
+    readonly id: string;
+    readonly kind: "agent" | "capability" | "middleware";
+    /** @deprecated Prefer beforeModelCall / afterModelCall flags. */
+    readonly hasMiddleware: boolean;
+    readonly instructions?: readonly string[];
+    readonly tools?: readonly ManifestTool[];
+    /** True when an implementations entry provides beforeModelCall for this capability. */
+    readonly beforeModelCall?: boolean;
+    /** True when an implementations entry provides afterModelCall for this capability. */
+    readonly afterModelCall?: boolean;
+    /**
+     * @deprecated Model resolution is Runtime-owned. Legacy local snapshots may still carry this;
+     * new manifests omit it.
+     */
+    readonly model?: Pick<ModelDirective, "id" | "controls">;
+}
+export interface AgentManifest {
+    readonly schemaVersion: ManifestSchemaVersion;
+    readonly id: string;
+    readonly name: string;
+    readonly outputSchema?: JsonObject;
+    readonly capabilities: readonly CapabilityManifest[];
+}

package/dist/types/manifest.js

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

package/dist/types/middleware.d.ts

@@ -0,0 +1,74 @@
+import type { ContextMutationOptions, ModelCandidate, ModelDirective, ModelToolCall, ModelConfigurationMutationOptions } from "./model.js";
+import type { InputEvent, TranscriptEntry } from "./transcript.js";
+import type { ContextItem, Tripwire } from "./shared.js";
+import type { AfterModelCallFn, BeforeModelCallFn } from "./dynamics.js";
+import type { Interaction, ToolDefinition, ToolResult } from "./tool.js";
+interface StepRequestBase {
+    /** Opaque identity of the execution that owns this Step. */
+    readonly executionId: string;
+    /** Opaque identity of the Turn that owns this Step. */
+    readonly turnId: string;
+    /** Opaque identity of this Model Step. */
+    readonly stepId: string;
+    readonly turnNumber: number;
+    readonly stepNumber: number;
+    readonly arrivals: readonly InputEvent[];
+    readonly toolResults: readonly ToolResult[];
+    readonly transcript: readonly TranscriptEntry[];
+    readonly context: {
+        set(slot: string, items: readonly ContextItem[], options?: ContextMutationOptions): void;
+    };
+    readonly configuration: {
+        readonly instructions: {
+            set(slot: string, items: readonly string[], options?: ModelConfigurationMutationOptions): void;
+        };
+        readonly tools: {
+            set(slot: string, tools: readonly ToolDefinition[], options?: ModelConfigurationMutationOptions): void;
+        };
+        readonly model: {
+            select(directive: ModelDirective, options?: Omit<ModelConfigurationMutationOptions, "order">): void;
+            replace(directive: ModelDirective, options?: Omit<ModelConfigurationMutationOptions, "order">): void;
+            clear(options?: Omit<ModelConfigurationMutationOptions, "order">): void;
+        };
+    };
+    tripwire(error: Tripwire): StepResponse;
+}
+export type StepRequest<Info = unknown> = StepRequestBase & {
+    readonly info?: Info;
+};
+export interface StepResponse {
+    candidate(): Readonly<ModelCandidate> | undefined;
+    toolCalls(): readonly ModelToolCall[];
+    replace(candidate: ModelCandidate): void;
+    deny(callId: string, reason: string): void;
+    requireInteraction(callId: string, interaction: Interaction): void;
+    tripwire(error: Tripwire): StepResponse;
+}
+export type StepMiddleware<Info = unknown> = (request: StepRequest<Info>, next: () => Promise<StepResponse>) => Promise<StepResponse>;
+export type CapabilityItems<Item> = readonly Item[] | Readonly<{
+    readonly slot: string;
+    readonly items: readonly Item[];
+}>;
+export interface CapabilityDeclaration<Info = unknown> {
+    readonly id: string;
+    readonly tools?: CapabilityItems<ToolDefinition<any, Info, any>>;
+    readonly instructions?: CapabilityItems<string>;
+    /**
+     * @deprecated Model resolution is Runtime-owned. Not projected into the harness manifest.
+     * Kept for local middleware composition through 1.0.
+     */
+    readonly model?: ModelDirective;
+    /** @deprecated Prefer beforeModelCall / afterModelCall. Kept through 1.0. */
+    readonly middleware?: StepMiddleware<Info>;
+    readonly beforeModelCall?: BeforeModelCallFn<Info>;
+    readonly afterModelCall?: AfterModelCallFn<Info>;
+}
+export interface MiddlewareContributions {
+    readonly instructions?: readonly string[];
+    readonly tools?: readonly {
+        readonly name: string;
+        readonly description?: string;
+    }[];
+    readonly model?: Pick<ModelDirective, "id" | "controls">;
+}
+export {};

package/dist/types/middleware.js

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

package/dist/types/model.d.ts

@@ -0,0 +1,184 @@
+import type { ContextItem, JsonObject, JsonValue } from "./shared.js";
+import type { InputEvent, TranscriptEntry } from "./transcript.js";
+import type { ToolDescriptor, ToolResult } from "./tool.js";
+export interface ModelToolCall {
+    readonly id: string;
+    readonly name: string;
+    readonly args: JsonObject;
+}
+export type ModelOutputBlock = {
+    readonly type: "text";
+    readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
+    readonly type: "reasoning";
+    readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
+    readonly type: "json";
+    readonly value: JsonValue;
+} | {
+    readonly type: "tool-call";
+    readonly providerMetadata?: JsonObject;
+    readonly id: string;
+    readonly name: string;
+    readonly args: JsonObject;
+    readonly raw?: string;
+};
+export interface ModelUsage {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+    readonly cachedTokens?: number;
+    readonly reasoningTokens?: number;
+    readonly costUsd?: number;
+}
+export type ModelFinishReason = "stop" | "length" | "tool-calls" | "content-filter" | "other";
+export interface ModelEvidence {
+    readonly requestId?: string;
+    readonly resolvedModel?: string;
+    readonly warnings?: readonly string[];
+    readonly extras?: JsonObject;
+}
+export interface ModelCandidate {
+    readonly output: readonly ModelOutputBlock[];
+    readonly finishReason?: ModelFinishReason;
+    readonly usage?: ModelUsage;
+    readonly evidence?: ModelEvidence;
+}
+export interface ModelControls {
+    readonly temperature?: number;
+    readonly maxOutputTokens?: number;
+}
+export interface ModelDirective {
+    readonly id?: string;
+    readonly controls?: ModelControls;
+    readonly config?: JsonObject;
+}
+/** A middleware-owned declaration for the model-visible configuration. */
+export interface ModelConfigurationMutationOptions {
+    readonly order?: number;
+    readonly reason?: string;
+}
+export interface ModelConfigurationContributor {
+    readonly middlewareId: string;
+    readonly slot: string;
+    readonly order: number;
+    readonly reason?: string;
+}
+export interface ModelConfigurationTool {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: JsonObject;
+    readonly outputSchema?: JsonObject;
+    readonly contributor: ModelConfigurationContributor;
+}
+export interface ModelConfigurationInstruction {
+    readonly text: string;
+    readonly contributor: ModelConfigurationContributor;
+}
+export interface ModelConfigurationSnapshot {
+    readonly version: 1;
+    readonly model?: ModelDirective;
+    readonly instructions: readonly ModelConfigurationInstruction[];
+    /** Data-only descriptions of the selected tools. */
+    readonly tools: readonly ToolDescriptor[];
+    readonly toolContracts: readonly ModelConfigurationTool[];
+    readonly contributors: readonly ModelConfigurationContributor[];
+}
+/** A middleware-owned declaration for this model call's runtime context. */
+export interface ContextMutationOptions {
+    readonly order?: number;
+    readonly reason?: string;
+}
+export interface ContextContributor {
+    readonly middlewareId: string;
+    readonly slot: string;
+    readonly order: number;
+    readonly reason?: string;
+}
+/** Canonical runtime context for one model call. */
+export interface ContextSnapshot {
+    readonly items: readonly ContextItem[];
+    readonly contributors: readonly ContextContributor[];
+}
+export interface ModelRequest {
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly model?: ModelDirective;
+    /** Canonical, immutable Harness-owned model configuration for this call. */
+    readonly configuration: ModelConfigurationSnapshot;
+    readonly instructions: readonly string[];
+    readonly context: ContextSnapshot;
+    readonly transcript: readonly TranscriptEntry[];
+    readonly arrivals: readonly InputEvent[];
+    readonly toolResults: readonly ToolResult[];
+    /** Immutable tool descriptions; executable definitions stay inside Harness. */
+    readonly tools: readonly ToolDescriptor[];
+    /** Optional portable contract for this turn's terminal JSON result. */
+    readonly outputSchema?: JsonObject;
+}
+export type PromptContentPart = {
+    readonly type: "reasoning";
+    readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
+    readonly type: "text";
+    readonly text: string;
+    readonly providerMetadata?: JsonObject;
+} | {
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly reference: JsonValue;
+} | {
+    readonly type: "tool-call";
+    readonly providerMetadata?: JsonObject;
+    readonly id: string;
+    readonly name: string;
+    readonly args: JsonObject;
+};
+export type PromptItem = {
+    readonly kind: "instructions";
+    readonly role: "system";
+    readonly content: readonly PromptContentPart[];
+} | {
+    readonly kind: "message";
+    readonly role: "user" | "assistant";
+    readonly content: readonly PromptContentPart[];
+} | {
+    readonly kind: "tool-result";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly status: "completed" | "denied" | "failed";
+    readonly content: readonly PromptContentPart[];
+} | {
+    readonly kind: "context";
+    readonly role: "user";
+    readonly content: readonly PromptContentPart[];
+};
+export interface ModelCallTool {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: JsonObject;
+}
+export interface ModelCall {
+    readonly model?: ModelDirective;
+    readonly prompt: readonly PromptItem[];
+    readonly tools: readonly ModelCallTool[];
+    /** Optional portable contract for this turn's terminal JSON result. */
+    readonly outputSchema?: JsonObject;
+    readonly executionId: string;
+}
+export interface ModelAdapterContext {
+    readonly request: ModelRequest;
+    readonly invocationId: string;
+    readonly signal: AbortSignal;
+    /** Publishes one JSON-safe provider request derived from the canonical ModelCall. */
+    reportPreparedCall(prepared: ModelPreparedCall): void;
+}
+export interface ModelPreparedCall {
+    readonly adapter: string;
+    readonly call: JsonValue;
+}
+export type ModelAdapter = (call: ModelCall, context: ModelAdapterContext) => Promise<ModelCandidate | string>;

package/dist/types/model.js

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

package/dist/types/observe.d.ts

@@ -0,0 +1,180 @@
+import type { ContextSnapshot, ModelCandidate, ModelCall, ModelConfigurationSnapshot } from "./model.js";
+import type { JsonObject, JsonValue } from "./shared.js";
+import type { InputEvent, TranscriptEntry } from "./transcript.js";
+import type { RequiredInteraction, ToolDescriptor, ToolResult } from "./tool.js";
+export type ObserveToolSnapshot = ToolDescriptor;
+/** JSON-only model-configuration view suitable for an observation stream. */
+export interface ObserveModelConfigurationSnapshot extends Omit<ModelConfigurationSnapshot, "tools"> {
+    readonly tools: readonly ObserveToolSnapshot[];
+}
+export interface ObserveSealedCall {
+    readonly callId: string;
+    readonly toolName: string;
+    readonly args: JsonValue;
+    readonly invocationId: string;
+    readonly owner: {
+        readonly middlewareId: string;
+        readonly slot: string;
+    };
+    readonly interaction?: RequiredInteraction;
+}
+export interface ObserveModelRequested {
+    /** The exact immutable logical input supplied to the ModelAdapter. */
+    readonly call: ModelCall;
+    /** Canonical configuration facts and attribution. */
+    readonly configuration: ObserveModelConfigurationSnapshot;
+    /** Current-step runtime context and attribution. */
+    readonly context: ContextSnapshot;
+}
+export type ObserveEvent = {
+    readonly type: "model.requested";
+    readonly invocationId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly requestedModelId?: string;
+    readonly attributes: ObserveModelRequested;
+} | {
+    readonly type: "model.prepared";
+    readonly invocationId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly requestedModelId?: string;
+    readonly attributes: {
+        readonly adapter: string;
+        readonly call: JsonValue;
+    };
+} | {
+    readonly type: "model.completed";
+    readonly invocationId?: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly requestedModelId?: string;
+    readonly attributes: ModelCandidate;
+} | {
+    readonly type: "step.started";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly turnNumber: number;
+    readonly stepNumber: number;
+    readonly attributes: {
+        readonly arrivals: readonly InputEvent[];
+        readonly toolResults: readonly ToolResult[];
+        readonly transcript: readonly TranscriptEntry[];
+    };
+} | {
+    readonly type: "middleware.entered" | "middleware.completed";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly middlewareId: string;
+} | {
+    readonly type: "middleware.lease-violation";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly middlewareId: string;
+    readonly reason: string;
+} | {
+    readonly type: "tool.sealed";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly attributes: {
+        readonly executable: readonly ObserveSealedCall[];
+        readonly immediate: readonly ToolResult[];
+    };
+} | {
+    readonly type: "tool.started";
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly toolName: string;
+    readonly callId: string;
+    readonly invocationId: string;
+    readonly middlewareId: string;
+    readonly slot: string;
+    readonly attributes: {
+        readonly args: JsonValue;
+    };
+} | {
+    readonly type: "tool.progress";
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly toolName: string;
+    readonly callId: string;
+    readonly invocationId: string;
+    readonly middlewareId: string;
+    readonly slot: string;
+    readonly attributes: {
+        readonly message: string;
+        readonly data?: JsonObject;
+    };
+} | {
+    readonly type: "tool.completed";
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly toolName: string;
+    readonly callId: string;
+    readonly invocationId: string;
+    readonly middlewareId: string;
+    readonly slot: string;
+    readonly outcome: string;
+    readonly code?: string;
+    readonly attributes?: ToolResult;
+} | {
+    readonly type: "tool.deferred";
+    readonly executionId: string;
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly toolName: string;
+    readonly callId: string;
+    readonly invocationId: string;
+    readonly middlewareId: string;
+    readonly slot: string;
+    readonly attributes: {
+        readonly token?: JsonValue;
+    };
+} | {
+    readonly type: "turn.completed";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly attributes: {
+        readonly output: JsonValue;
+    };
+} | {
+    readonly type: "interaction.required";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly inputId?: string;
+    readonly interactionId: string;
+    readonly kind: string;
+    readonly callId?: string;
+    readonly toolName?: string;
+    readonly phase?: "interaction" | "execute";
+    readonly attributes: {
+        readonly prompt: string;
+        readonly metadata?: JsonObject;
+    };
+} | {
+    readonly type: "tripwire";
+    readonly turnId: string;
+    readonly stepId?: string;
+    readonly inputId?: string;
+    readonly code: string;
+    readonly scope: string;
+    readonly attributes: {
+        readonly message: string;
+    };
+};
+export type Observer = (event: ObserveEvent) => void | Promise<void>;

package/dist/types/observe.js

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

package/dist/types/shared.d.ts

@@ -0,0 +1,25 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+export interface DeferredOutcome {
+    readonly kind: "deferred";
+    readonly token?: JsonValue;
+}
+export interface BuildDiagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly toolName?: string;
+    readonly details?: Readonly<Record<string, string | number | boolean>>;
+    readonly cause?: unknown;
+}
+export interface ContextItem {
+    readonly type?: string;
+    readonly value: JsonValue;
+}
+export interface Tripwire {
+    readonly code: string;
+    readonly message: string;
+    readonly scope?: "step" | "execution";
+}

package/dist/types/shared.js

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