@openwaggle/extension-sdk 0.0.0-bootstrap.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.1.0 (2026-07-14)
+
+
+### Features
+
+* implement OpenWaggle extension contribution host ([e813eb0](https://github.com/OpenWaggle/OpenWaggle/commit/e813eb0de79ecc57ce62f2bb52e7237d3715f4fa))
+
+## Changelog
+
+This package is not published yet. Release Please will maintain future package release notes here.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenWaggle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @openwaggle/extension-sdk
+
+Browser-safe OpenWaggle extension SDK schemas, types, manifest validation, broker helpers, theme tokens, and federated-module context helpers.

package/dist/agent-loop.d.ts

@@ -0,0 +1,128 @@
+import * as Schema from 'effect/Schema';
+import { type JsonValue } from './json.js';
+export interface OpenWaggleToolCallSurfaceInput {
+    readonly surface: 'tool';
+    readonly toolCall: {
+        readonly id: string;
+        readonly name: string;
+        readonly input?: JsonValue;
+    };
+    readonly toolResult?: {
+        readonly ok: boolean;
+        readonly output?: JsonValue;
+        readonly error?: string;
+    };
+}
+export interface OpenWaggleCustomMessageSurfaceInput {
+    readonly surface: 'custom-message';
+    readonly message: {
+        readonly name: string;
+        readonly payload?: JsonValue;
+    };
+}
+export interface OpenWaggleInteractionSurfaceInput {
+    readonly surface: 'interaction';
+    readonly interaction: {
+        readonly id: string;
+        readonly customType: string;
+        readonly payload?: JsonValue;
+    };
+}
+export interface OpenWaggleTranscriptSurfaceInput {
+    readonly surface: 'transcript';
+    readonly transcript: {
+        readonly sessionId?: string;
+        readonly messageCount: number;
+        readonly payload?: JsonValue;
+    };
+}
+export interface OpenWaggleStatusSurfaceInput {
+    readonly surface: 'status';
+    readonly status: {
+        readonly label: string;
+        readonly payload?: JsonValue;
+    };
+}
+export type OpenWaggleAgentLoopSurfaceInput = OpenWaggleToolCallSurfaceInput | OpenWaggleCustomMessageSurfaceInput | OpenWaggleInteractionSurfaceInput | OpenWaggleTranscriptSurfaceInput | OpenWaggleStatusSurfaceInput;
+export declare const openWaggleToolCallSurfaceInputSchema: Schema.Struct<{
+    surface: Schema.Literal<["tool"]>;
+    toolCall: Schema.Struct<{
+        id: Schema.filter<typeof Schema.String>;
+        name: Schema.filter<typeof Schema.String>;
+        input: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+    toolResult: Schema.optional<Schema.Struct<{
+        ok: typeof Schema.Boolean;
+        output: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+        error: Schema.optional<typeof Schema.String>;
+    }>>;
+}>;
+export declare const openWaggleCustomMessageSurfaceInputSchema: Schema.Struct<{
+    surface: Schema.Literal<["custom-message"]>;
+    message: Schema.Struct<{
+        name: Schema.filter<typeof Schema.String>;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>;
+export declare const openWaggleInteractionSurfaceInputSchema: Schema.Struct<{
+    surface: Schema.Literal<["interaction"]>;
+    interaction: Schema.Struct<{
+        id: Schema.filter<typeof Schema.String>;
+        customType: Schema.filter<typeof Schema.String>;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>;
+export declare const openWaggleTranscriptSurfaceInputSchema: Schema.Struct<{
+    surface: Schema.Literal<["transcript"]>;
+    transcript: Schema.Struct<{
+        sessionId: Schema.optional<Schema.filter<typeof Schema.String>>;
+        messageCount: typeof Schema.Number;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>;
+export declare const openWaggleStatusSurfaceInputSchema: Schema.Struct<{
+    surface: Schema.Literal<["status"]>;
+    status: Schema.Struct<{
+        label: Schema.filter<typeof Schema.String>;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>;
+export declare const openWaggleAgentLoopSurfaceInputSchema: Schema.Union<[Schema.Struct<{
+    surface: Schema.Literal<["tool"]>;
+    toolCall: Schema.Struct<{
+        id: Schema.filter<typeof Schema.String>;
+        name: Schema.filter<typeof Schema.String>;
+        input: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+    toolResult: Schema.optional<Schema.Struct<{
+        ok: typeof Schema.Boolean;
+        output: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+        error: Schema.optional<typeof Schema.String>;
+    }>>;
+}>, Schema.Struct<{
+    surface: Schema.Literal<["custom-message"]>;
+    message: Schema.Struct<{
+        name: Schema.filter<typeof Schema.String>;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>, Schema.Struct<{
+    surface: Schema.Literal<["interaction"]>;
+    interaction: Schema.Struct<{
+        id: Schema.filter<typeof Schema.String>;
+        customType: Schema.filter<typeof Schema.String>;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>, Schema.Struct<{
+    surface: Schema.Literal<["transcript"]>;
+    transcript: Schema.Struct<{
+        sessionId: Schema.optional<Schema.filter<typeof Schema.String>>;
+        messageCount: typeof Schema.Number;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>, Schema.Struct<{
+    surface: Schema.Literal<["status"]>;
+    status: Schema.Struct<{
+        label: Schema.filter<typeof Schema.String>;
+        payload: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    }>;
+}>]>;

package/dist/agent-loop.js

@@ -0,0 +1,47 @@
+import * as Schema from 'effect/Schema';
+import { jsonValueSchema } from './json.js';
+const nonEmptyStringSchema = Schema.String.pipe(Schema.minLength(1));
+export const openWaggleToolCallSurfaceInputSchema = Schema.Struct({
+    surface: Schema.Literal('tool'),
+    toolCall: Schema.Struct({
+        id: nonEmptyStringSchema,
+        name: nonEmptyStringSchema,
+        input: Schema.optional(jsonValueSchema),
+    }),
+    toolResult: Schema.optional(Schema.Struct({
+        ok: Schema.Boolean,
+        output: Schema.optional(jsonValueSchema),
+        error: Schema.optional(Schema.String),
+    })),
+});
+export const openWaggleCustomMessageSurfaceInputSchema = Schema.Struct({
+    surface: Schema.Literal('custom-message'),
+    message: Schema.Struct({
+        name: nonEmptyStringSchema,
+        payload: Schema.optional(jsonValueSchema),
+    }),
+});
+export const openWaggleInteractionSurfaceInputSchema = Schema.Struct({
+    surface: Schema.Literal('interaction'),
+    interaction: Schema.Struct({
+        id: nonEmptyStringSchema,
+        customType: nonEmptyStringSchema,
+        payload: Schema.optional(jsonValueSchema),
+    }),
+});
+export const openWaggleTranscriptSurfaceInputSchema = Schema.Struct({
+    surface: Schema.Literal('transcript'),
+    transcript: Schema.Struct({
+        sessionId: Schema.optional(nonEmptyStringSchema),
+        messageCount: Schema.Number,
+        payload: Schema.optional(jsonValueSchema),
+    }),
+});
+export const openWaggleStatusSurfaceInputSchema = Schema.Struct({
+    surface: Schema.Literal('status'),
+    status: Schema.Struct({
+        label: nonEmptyStringSchema,
+        payload: Schema.optional(jsonValueSchema),
+    }),
+});
+export const openWaggleAgentLoopSurfaceInputSchema = Schema.Union(openWaggleToolCallSurfaceInputSchema, openWaggleCustomMessageSurfaceInputSchema, openWaggleInteractionSurfaceInputSchema, openWaggleTranscriptSurfaceInputSchema, openWaggleStatusSurfaceInputSchema);

package/dist/broker-validation.d.ts

@@ -0,0 +1,17 @@
+import type { ExtensionRuntimeRegisterContributionResult, ExtensionRuntimeUnregisterContributionResult } from './runtime-types.js';
+import type { ExtensionStorageDeleteResult, ExtensionStorageGetResult, ExtensionStorageListResult, ExtensionStorageSetResult } from './storage-types.js';
+import type { ExtensionCapabilityAuditEntry, ExtensionInvokeFailure, ExtensionInvokeResult } from './types.js';
+type OperationResultGuard<TValue> = (value: unknown) => value is TValue;
+export declare function invalidOperationResult(input: {
+    readonly audit: ExtensionCapabilityAuditEntry;
+    readonly issues: readonly string[];
+    readonly message: string;
+}): ExtensionInvokeFailure;
+export declare function toDecodedOperationResult<TValue>(result: ExtensionInvokeResult, guard: OperationResultGuard<TValue>, message: string): ExtensionInvokeResult<TValue>;
+export declare function isStorageGetResult(value: unknown): value is ExtensionStorageGetResult;
+export declare function isStorageSetResult(value: unknown): value is ExtensionStorageSetResult;
+export declare function isStorageDeleteResult(value: unknown): value is ExtensionStorageDeleteResult;
+export declare function isStorageListResult(value: unknown): value is ExtensionStorageListResult;
+export declare function isRuntimeRegisterContributionResult(value: unknown): value is ExtensionRuntimeRegisterContributionResult;
+export declare function isRuntimeUnregisterContributionResult(value: unknown): value is ExtensionRuntimeUnregisterContributionResult;
+export {};

package/dist/broker-validation.js

@@ -0,0 +1,99 @@
+import { OPENWAGGLE_EXTENSION, OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+import { isJsonValue, isNonEmptyString, isRecord, isStringArray } from './internal-validation.js';
+export function invalidOperationResult(input) {
+    return {
+        ok: false,
+        error: {
+            code: OPENWAGGLE_EXTENSION_BROKER.FAILURE_CODE.INVALID_PAYLOAD,
+            message: input.message,
+            issues: [...input.issues],
+        },
+        audit: input.audit,
+    };
+}
+export function toDecodedOperationResult(result, guard, message) {
+    if (!result.ok) {
+        return result;
+    }
+    return guard(result.value)
+        ? { ok: true, value: result.value, audit: result.audit }
+        : invalidOperationResult({
+            audit: result.audit,
+            issues: ['Broker response payload did not match the expected operation result.'],
+            message,
+        });
+}
+function isKnownString(values, value) {
+    return typeof value === 'string' && values.some((candidate) => candidate === value);
+}
+function isStorageScope(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.kind === OPENWAGGLE_EXTENSION.STORAGE.SCOPE.GLOBAL_KIND) {
+        return true;
+    }
+    return (value.kind === OPENWAGGLE_EXTENSION.STORAGE.SCOPE.PROJECT_KIND &&
+        isNonEmptyString(value.projectPath));
+}
+function isStorageKey(value) {
+    return (isNonEmptyString(value) &&
+        value === value.trim() &&
+        value.length <= OPENWAGGLE_EXTENSION.STORAGE.KEY_MAX_LENGTH);
+}
+function hasStorageResultBase(value) {
+    return (isNonEmptyString(value.extensionId) &&
+        isNonEmptyString(value.contributionId) &&
+        value.capability === OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STORAGE &&
+        isKnownString(OPENWAGGLE_EXTENSION.STORAGE.KINDS, value.storageKind) &&
+        isStorageScope(value.storageScope));
+}
+export function isStorageGetResult(value) {
+    return (isRecord(value) &&
+        hasStorageResultBase(value) &&
+        value.method === OPENWAGGLE_EXTENSION_BROKER.METHOD.GET &&
+        isStorageKey(value.key) &&
+        (value.value === null || isJsonValue(value.value)));
+}
+export function isStorageSetResult(value) {
+    return (isRecord(value) &&
+        hasStorageResultBase(value) &&
+        value.method === OPENWAGGLE_EXTENSION_BROKER.METHOD.SET &&
+        isStorageKey(value.key) &&
+        isJsonValue(value.value) &&
+        typeof value.createdAt === 'number' &&
+        typeof value.updatedAt === 'number');
+}
+export function isStorageDeleteResult(value) {
+    return (isRecord(value) &&
+        hasStorageResultBase(value) &&
+        value.method === OPENWAGGLE_EXTENSION_BROKER.METHOD.DELETE &&
+        isStorageKey(value.key) &&
+        value.deleted === true);
+}
+export function isStorageListResult(value) {
+    return (isRecord(value) &&
+        hasStorageResultBase(value) &&
+        value.method === OPENWAGGLE_EXTENSION_BROKER.METHOD.LIST &&
+        isStringArray(value.keys) &&
+        value.keys.every(isStorageKey));
+}
+function hasRuntimeContributionResultBase(value) {
+    return (isNonEmptyString(value.extensionId) &&
+        isNonEmptyString(value.contributionId) &&
+        value.capability === OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.RUNTIME &&
+        isKnownString(OPENWAGGLE_EXTENSION.CONTRIBUTION_FAMILIES, value.family));
+}
+export function isRuntimeRegisterContributionResult(value) {
+    return (isRecord(value) &&
+        hasRuntimeContributionResultBase(value) &&
+        value.method === OPENWAGGLE_EXTENSION_BROKER.METHOD.REGISTER_CONTRIBUTION &&
+        isNonEmptyString(value.registeredContributionId));
+}
+export function isRuntimeUnregisterContributionResult(value) {
+    return (isRecord(value) &&
+        hasRuntimeContributionResultBase(value) &&
+        value.method === OPENWAGGLE_EXTENSION_BROKER.METHOD.UNREGISTER_CONTRIBUTION &&
+        isNonEmptyString(value.unregisteredContributionId) &&
+        typeof value.unregistered === 'boolean');
+}

package/dist/broker.d.ts

@@ -0,0 +1,193 @@
+import * as Schema from 'effect/Schema';
+import type { CreateOpenWaggleSdkOptions, ExtensionBrokerSdk, ExtensionBrokerTransport, ExtensionSdkIdentity, ExtensionSdkInvoke, ExtensionSdkInvokeRequest } from './sdk-types.js';
+import type { ExtensionInvokeInput } from './types.js';
+export type * from './core-types.js';
+export type * from './sdk-types.js';
+export declare const extensionInvokeScopeSchema: Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["app"]>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["project"]>;
+    projectPath: Schema.filter<typeof Schema.String>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["session"]>;
+    projectPath: Schema.filter<typeof Schema.String>;
+    sessionId: Schema.filter<typeof Schema.String>;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["branch"]>;
+    projectPath: Schema.filter<typeof Schema.String>;
+    sessionId: Schema.filter<typeof Schema.String>;
+    branchId: Schema.filter<typeof Schema.String>;
+}>]>;
+export declare const extensionCapabilityAuditEntrySchema: Schema.Struct<{
+    extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    capability: Schema.filter<Schema.filter<typeof Schema.String>>;
+    method: Schema.filter<Schema.filter<typeof Schema.String>>;
+    scope: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["app"]>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["project"]>;
+        projectPath: Schema.filter<typeof Schema.String>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["session"]>;
+        projectPath: Schema.filter<typeof Schema.String>;
+        sessionId: Schema.filter<typeof Schema.String>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["branch"]>;
+        projectPath: Schema.filter<typeof Schema.String>;
+        sessionId: Schema.filter<typeof Schema.String>;
+        branchId: Schema.filter<typeof Schema.String>;
+    }>]>;
+    outcome: Schema.SchemaClass<"succeeded" | "rejected", "succeeded" | "rejected", never>;
+    timestamp: typeof Schema.Number;
+    failureCode: Schema.optional<Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>>;
+}>;
+export declare const extensionInvokeInputSchema: Schema.Struct<{
+    extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    capability: Schema.filter<Schema.filter<typeof Schema.String>>;
+    method: Schema.filter<Schema.filter<typeof Schema.String>>;
+    scope: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["app"]>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["project"]>;
+        projectPath: Schema.filter<typeof Schema.String>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["session"]>;
+        projectPath: Schema.filter<typeof Schema.String>;
+        sessionId: Schema.filter<typeof Schema.String>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["branch"]>;
+        projectPath: Schema.filter<typeof Schema.String>;
+        sessionId: Schema.filter<typeof Schema.String>;
+        branchId: Schema.filter<typeof Schema.String>;
+    }>]>;
+    payload: Schema.optional<typeof Schema.Unknown>;
+}>;
+export declare const extensionInvokeErrorSchema: Schema.Struct<{
+    code: Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>;
+    message: Schema.filter<typeof Schema.String>;
+    issues: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+export declare const extensionInvokeSuccessSchema: Schema.Struct<{
+    ok: Schema.Literal<[true]>;
+    value: typeof Schema.Unknown;
+    audit: Schema.Struct<{
+        extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        capability: Schema.filter<Schema.filter<typeof Schema.String>>;
+        method: Schema.filter<Schema.filter<typeof Schema.String>>;
+        scope: Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["app"]>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["project"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["session"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["branch"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+            branchId: Schema.filter<typeof Schema.String>;
+        }>]>;
+        outcome: Schema.SchemaClass<"succeeded" | "rejected", "succeeded" | "rejected", never>;
+        timestamp: typeof Schema.Number;
+        failureCode: Schema.optional<Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>>;
+    }>;
+}>;
+export declare const extensionInvokeFailureSchema: Schema.Struct<{
+    ok: Schema.Literal<[false]>;
+    error: Schema.Struct<{
+        code: Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>;
+        message: Schema.filter<typeof Schema.String>;
+        issues: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }>;
+    audit: Schema.optional<Schema.Struct<{
+        extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        capability: Schema.filter<Schema.filter<typeof Schema.String>>;
+        method: Schema.filter<Schema.filter<typeof Schema.String>>;
+        scope: Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["app"]>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["project"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["session"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["branch"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+            branchId: Schema.filter<typeof Schema.String>;
+        }>]>;
+        outcome: Schema.SchemaClass<"succeeded" | "rejected", "succeeded" | "rejected", never>;
+        timestamp: typeof Schema.Number;
+        failureCode: Schema.optional<Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>>;
+    }>>;
+}>;
+export declare const extensionInvokeResultSchema: Schema.Union<[Schema.Struct<{
+    ok: Schema.Literal<[true]>;
+    value: typeof Schema.Unknown;
+    audit: Schema.Struct<{
+        extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        capability: Schema.filter<Schema.filter<typeof Schema.String>>;
+        method: Schema.filter<Schema.filter<typeof Schema.String>>;
+        scope: Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["app"]>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["project"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["session"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["branch"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+            branchId: Schema.filter<typeof Schema.String>;
+        }>]>;
+        outcome: Schema.SchemaClass<"succeeded" | "rejected", "succeeded" | "rejected", never>;
+        timestamp: typeof Schema.Number;
+        failureCode: Schema.optional<Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>>;
+    }>;
+}>, Schema.Struct<{
+    ok: Schema.Literal<[false]>;
+    error: Schema.Struct<{
+        code: Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>;
+        message: Schema.filter<typeof Schema.String>;
+        issues: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }>;
+    audit: Schema.optional<Schema.Struct<{
+        extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+        capability: Schema.filter<Schema.filter<typeof Schema.String>>;
+        method: Schema.filter<Schema.filter<typeof Schema.String>>;
+        scope: Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["app"]>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["project"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["session"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+        }>, Schema.Struct<{
+            kind: Schema.Literal<["branch"]>;
+            projectPath: Schema.filter<typeof Schema.String>;
+            sessionId: Schema.filter<typeof Schema.String>;
+            branchId: Schema.filter<typeof Schema.String>;
+        }>]>;
+        outcome: Schema.SchemaClass<"succeeded" | "rejected", "succeeded" | "rejected", never>;
+        timestamp: typeof Schema.Number;
+        failureCode: Schema.optional<Schema.SchemaClass<"invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", "invalid-input" | "invalid-payload" | "unknown-extension" | "disabled-extension" | "unknown-contribution" | "undeclared-capability" | "undeclared-method" | "undeclared-scope" | "out-of-scope" | "unsupported-capability" | "unsupported-method" | "transport-failed", never>>;
+    }>>;
+}>]>;
+export declare function toInvokeInput(identity: ExtensionSdkIdentity, request: ExtensionSdkInvokeRequest): ExtensionInvokeInput;
+export declare function createExtensionBrokerSdkFromInvoke(invoke: ExtensionSdkInvoke, options?: CreateOpenWaggleSdkOptions): ExtensionBrokerSdk;
+export declare function createExtensionBrokerSdk(transport: ExtensionBrokerTransport, identity: ExtensionSdkIdentity, options?: CreateOpenWaggleSdkOptions): ExtensionBrokerSdk;

package/dist/broker.js

@@ -0,0 +1,81 @@
+import * as Schema from 'effect/Schema';
+import { OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+import { extensionContributionIdSchema, extensionIdSchema } from './manifest.js';
+import { createOpenWaggleSdk } from './openwaggle-sdk.js';
+import { createRuntimeContributionSdk } from './runtime-sdk.js';
+import { createPackageStorageSdk } from './storage-sdk.js';
+const nonEmptyStringSchema = Schema.String.pipe(Schema.minLength(1));
+export const extensionInvokeScopeSchema = Schema.Union(Schema.Struct({ kind: Schema.Literal('app') }), Schema.Struct({ kind: Schema.Literal('project'), projectPath: nonEmptyStringSchema }), Schema.Struct({
+    kind: Schema.Literal('session'),
+    projectPath: nonEmptyStringSchema,
+    sessionId: nonEmptyStringSchema,
+}), Schema.Struct({
+    kind: Schema.Literal('branch'),
+    projectPath: nonEmptyStringSchema,
+    sessionId: nonEmptyStringSchema,
+    branchId: nonEmptyStringSchema,
+}));
+export const extensionCapabilityAuditEntrySchema = Schema.Struct({
+    extensionId: extensionIdSchema,
+    contributionId: extensionContributionIdSchema,
+    capability: extensionContributionIdSchema,
+    method: extensionContributionIdSchema,
+    scope: extensionInvokeScopeSchema,
+    outcome: Schema.Literal(...OPENWAGGLE_EXTENSION_BROKER.OUTCOMES),
+    timestamp: Schema.Number,
+    failureCode: Schema.optional(Schema.Literal(...OPENWAGGLE_EXTENSION_BROKER.FAILURE_CODES)),
+});
+export const extensionInvokeInputSchema = Schema.Struct({
+    extensionId: extensionIdSchema,
+    contributionId: extensionContributionIdSchema,
+    capability: extensionContributionIdSchema,
+    method: extensionContributionIdSchema,
+    scope: extensionInvokeScopeSchema,
+    payload: Schema.optional(Schema.Unknown),
+});
+export const extensionInvokeErrorSchema = Schema.Struct({
+    code: Schema.Literal(...OPENWAGGLE_EXTENSION_BROKER.FAILURE_CODES),
+    message: nonEmptyStringSchema,
+    issues: Schema.optional(Schema.Array(Schema.String)),
+});
+export const extensionInvokeSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    value: Schema.Unknown,
+    audit: extensionCapabilityAuditEntrySchema,
+});
+export const extensionInvokeFailureSchema = Schema.Struct({
+    ok: Schema.Literal(false),
+    error: extensionInvokeErrorSchema,
+    audit: Schema.optional(extensionCapabilityAuditEntrySchema),
+});
+export const extensionInvokeResultSchema = Schema.Union(extensionInvokeSuccessSchema, extensionInvokeFailureSchema);
+export function toInvokeInput(identity, request) {
+    return {
+        extensionId: identity.extensionId,
+        contributionId: identity.contributionId,
+        capability: request.capability,
+        method: request.method,
+        scope: request.scope,
+        ...(request.payload !== undefined ? { payload: request.payload } : {}),
+    };
+}
+export function createExtensionBrokerSdkFromInvoke(invoke, options = {}) {
+    return {
+        invoke,
+        hostContext: {
+            getScope: (scope) => invoke({
+                capability: OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.HOST_CONTEXT,
+                method: OPENWAGGLE_EXTENSION_BROKER.METHOD.GET_SCOPE,
+                scope,
+                payload: {},
+            }),
+        },
+        storage: createPackageStorageSdk(invoke),
+        openWaggle: createOpenWaggleSdk(invoke, options),
+        runtime: createRuntimeContributionSdk(invoke),
+    };
+}
+export function createExtensionBrokerSdk(transport, identity, options = {}) {
+    const invoke = (request) => transport(toInvokeInput(identity, request));
+    return createExtensionBrokerSdkFromInvoke(invoke, options);
+}