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

package/dist/openwaggle-validation.d.ts

@@ -0,0 +1,12 @@
+import type { ExtensionActionSelectProjectResult, ExtensionSettingsGetResult, ExtensionSettingsGetSettingResult, ExtensionSettingsUpdateResult, ExtensionSettingsUpdateSettingResult, ExtensionStateCurrentBranchReadResult, ExtensionStateCurrentProjectReadResult, ExtensionStateCurrentSessionReadResult, ExtensionStateModelPreferencesReadResult, ExtensionStateReadResult, ExtensionStateRecentProjectsReadResult } from './types.js';
+export declare function isStateReadResult(value: unknown): value is ExtensionStateReadResult;
+export declare function isStateCurrentProjectReadResult(value: unknown): value is ExtensionStateCurrentProjectReadResult;
+export declare function isStateCurrentSessionReadResult(value: unknown): value is ExtensionStateCurrentSessionReadResult;
+export declare function isStateCurrentBranchReadResult(value: unknown): value is ExtensionStateCurrentBranchReadResult;
+export declare function isStateRecentProjectsReadResult(value: unknown): value is ExtensionStateRecentProjectsReadResult;
+export declare function isStateModelPreferencesReadResult(value: unknown): value is ExtensionStateModelPreferencesReadResult;
+export declare function isActionSelectProjectResult(value: unknown): value is ExtensionActionSelectProjectResult;
+export declare function isSettingsGetResult(value: unknown): value is ExtensionSettingsGetResult;
+export declare function isSettingsUpdateResult(value: unknown): value is ExtensionSettingsUpdateResult;
+export declare function isSettingsGetSettingResult(value: unknown): value is ExtensionSettingsGetSettingResult;
+export declare function isSettingsUpdateSettingResult(value: unknown): value is ExtensionSettingsUpdateSettingResult;

package/dist/openwaggle-validation.js

@@ -0,0 +1,135 @@
+import { OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+import { isNonEmptyString, isRecord, isStringArray } from './internal-validation.js';
+function isStringOrNull(value) {
+    return value === null || typeof value === 'string';
+}
+function isInvokeScope(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.kind === 'app') {
+        return true;
+    }
+    if (value.kind === 'project') {
+        return isNonEmptyString(value.projectPath);
+    }
+    if (value.kind === 'session') {
+        return isNonEmptyString(value.projectPath) && isNonEmptyString(value.sessionId);
+    }
+    return (value.kind === 'branch' &&
+        isNonEmptyString(value.projectPath) &&
+        isNonEmptyString(value.sessionId) &&
+        isNonEmptyString(value.branchId));
+}
+function isStringRecord(value) {
+    return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'string');
+}
+function isModelPreferences(value) {
+    return (isRecord(value) &&
+        typeof value.selectedModel === 'string' &&
+        isStringArray(value.favoriteModels) &&
+        isStringArray(value.enabledModels) &&
+        typeof value.thinkingLevel === 'string');
+}
+function isProjectView(value) {
+    return (isRecord(value) &&
+        isNonEmptyString(value.projectPath) &&
+        isStringOrNull(value.displayName) &&
+        typeof value.active === 'boolean');
+}
+function isSessionView(value) {
+    return (isRecord(value) &&
+        isNonEmptyString(value.sessionId) &&
+        isNonEmptyString(value.title) &&
+        isStringOrNull(value.projectPath));
+}
+function isBranchView(value) {
+    return (isRecord(value) &&
+        isNonEmptyString(value.branchId) &&
+        isNonEmptyString(value.sessionId) &&
+        isNonEmptyString(value.name) &&
+        typeof value.main === 'boolean' &&
+        typeof value.archived === 'boolean');
+}
+function hasOpenWaggleResultBase(value, capability, method) {
+    return (isNonEmptyString(value.extensionId) &&
+        isNonEmptyString(value.contributionId) &&
+        value.capability === capability &&
+        value.method === method);
+}
+export function isStateReadResult(value) {
+    return (isRecord(value) &&
+        hasOpenWaggleResultBase(value, OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STATE, OPENWAGGLE_EXTENSION_BROKER.METHOD.GET_STATE) &&
+        isInvokeScope(value.scope) &&
+        isStringOrNull(value.activeProjectPath) &&
+        (value.currentProject === null || isProjectView(value.currentProject)) &&
+        (value.currentSession === null || isSessionView(value.currentSession)) &&
+        (value.currentBranch === null || isBranchView(value.currentBranch)) &&
+        isStringArray(value.recentProjects) &&
+        isModelPreferences(value.modelPreferences));
+}
+function isSelectedStateResult(value, selector, isSelectedValue) {
+    return (isRecord(value) &&
+        hasOpenWaggleResultBase(value, OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STATE, OPENWAGGLE_EXTENSION_BROKER.METHOD.READ_STATE) &&
+        isInvokeScope(value.scope) &&
+        value.selector === selector &&
+        isSelectedValue(value.value));
+}
+export function isStateCurrentProjectReadResult(value) {
+    return isSelectedStateResult(value, OPENWAGGLE_EXTENSION_BROKER.STATE_SELECTOR.CURRENT_PROJECT, (selectedValue) => selectedValue === null || isProjectView(selectedValue));
+}
+export function isStateCurrentSessionReadResult(value) {
+    return isSelectedStateResult(value, OPENWAGGLE_EXTENSION_BROKER.STATE_SELECTOR.CURRENT_SESSION, (selectedValue) => selectedValue === null || isSessionView(selectedValue));
+}
+export function isStateCurrentBranchReadResult(value) {
+    return isSelectedStateResult(value, OPENWAGGLE_EXTENSION_BROKER.STATE_SELECTOR.CURRENT_BRANCH, (selectedValue) => selectedValue === null || isBranchView(selectedValue));
+}
+export function isStateRecentProjectsReadResult(value) {
+    return isSelectedStateResult(value, OPENWAGGLE_EXTENSION_BROKER.STATE_SELECTOR.RECENT_PROJECTS, isStringArray);
+}
+export function isStateModelPreferencesReadResult(value) {
+    return isSelectedStateResult(value, OPENWAGGLE_EXTENSION_BROKER.STATE_SELECTOR.MODEL_PREFERENCES, isModelPreferences);
+}
+export function isActionSelectProjectResult(value) {
+    return (isRecord(value) &&
+        hasOpenWaggleResultBase(value, OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.ACTIONS, OPENWAGGLE_EXTENSION_BROKER.METHOD.SELECT_PROJECT) &&
+        isStringOrNull(value.previousProjectPath) &&
+        isNonEmptyString(value.projectPath) &&
+        isStringArray(value.recentProjects));
+}
+function isSettingsView(value) {
+    return (isRecord(value) &&
+        isModelPreferences(value.modelPreferences) &&
+        isStringRecord(value.projectDisplayNames));
+}
+function isSettingsSelectedValue(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.key === OPENWAGGLE_EXTENSION_BROKER.SETTING_KEY.MODEL_PREFERENCES) {
+        return isModelPreferences(value.value);
+    }
+    return (value.key === OPENWAGGLE_EXTENSION_BROKER.SETTING_KEY.PROJECT_DISPLAY_NAME &&
+        isNonEmptyString(value.projectPath) &&
+        isStringOrNull(value.value));
+}
+export function isSettingsGetResult(value) {
+    return (isRecord(value) &&
+        hasOpenWaggleResultBase(value, OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.SETTINGS, OPENWAGGLE_EXTENSION_BROKER.METHOD.GET_SETTINGS) &&
+        isSettingsView(value.settings));
+}
+export function isSettingsUpdateResult(value) {
+    return (isRecord(value) &&
+        hasOpenWaggleResultBase(value, OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.SETTINGS, OPENWAGGLE_EXTENSION_BROKER.METHOD.UPDATE_SETTINGS) &&
+        isSettingsView(value.settings));
+}
+export function isSettingsGetSettingResult(value) {
+    return (isRecord(value) &&
+        hasOpenWaggleResultBase(value, OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.SETTINGS, OPENWAGGLE_EXTENSION_BROKER.METHOD.GET_SETTING) &&
+        isSettingsSelectedValue(value.setting));
+}
+export function isSettingsUpdateSettingResult(value) {
+    return (isRecord(value) &&
+        hasOpenWaggleResultBase(value, OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.SETTINGS, OPENWAGGLE_EXTENSION_BROKER.METHOD.UPDATE_SETTING) &&
+        isSettingsSelectedValue(value.setting));
+}

package/dist/registry-types.d.ts

@@ -0,0 +1,34 @@
+import type { ExtensionCapabilityScope, ExtensionContributionFamily, ExtensionContributionMatchView, ExtensionContributionRuntime, ExtensionContributionTargetView, ExtensionExecutionPlacement } from './contribution-types.js';
+export type ExtensionPackageScopeKind = 'global' | 'project';
+export interface ExtensionPackageScopeView {
+    readonly kind: ExtensionPackageScopeKind;
+    readonly label: string;
+    readonly projectPath?: string;
+}
+export interface ExtensionContributionRegistryEntry {
+    readonly extensionId: string;
+    readonly extensionName: string;
+    readonly extensionVersion: string;
+    readonly scope: ExtensionPackageScopeView;
+    readonly packagePath: string;
+    readonly manifestPath: string;
+    readonly contentHash: string;
+    readonly projectPaths: readonly string[];
+    readonly sessionId?: string;
+    readonly appliesToAllRequestedProjects: boolean;
+    readonly family: ExtensionContributionFamily;
+    readonly contributionId: string;
+    readonly title: string;
+    readonly label: string;
+    readonly category?: string;
+    readonly capability?: string;
+    readonly method?: string;
+    readonly methods?: readonly string[];
+    readonly declaredScopes?: readonly ExtensionCapabilityScope[];
+    readonly networkOrigins?: readonly string[];
+    readonly target?: ExtensionContributionTargetView;
+    readonly matches?: ExtensionContributionMatchView;
+    readonly runtime?: ExtensionContributionRuntime;
+    readonly execution?: ExtensionExecutionPlacement;
+    readonly entryPath?: string;
+}

package/dist/registry-types.js

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

package/dist/runtime-sdk.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionRuntimeContributionSdk, ExtensionSdkInvoke } from './sdk-types.js';
+export declare function createRuntimeContributionSdk(invoke: ExtensionSdkInvoke): ExtensionRuntimeContributionSdk;

package/dist/runtime-sdk.js

@@ -0,0 +1,19 @@
+import { isRuntimeRegisterContributionResult, isRuntimeUnregisterContributionResult, toDecodedOperationResult, } from './broker-validation.js';
+import { OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+const RUNTIME_CONTRIBUTION_RESULT_ERROR = 'Extension broker returned an invalid runtime contribution result.';
+export function createRuntimeContributionSdk(invoke) {
+    return {
+        registerContribution: async (scope, registration) => toDecodedOperationResult(await invoke({
+            capability: OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.RUNTIME,
+            method: OPENWAGGLE_EXTENSION_BROKER.METHOD.REGISTER_CONTRIBUTION,
+            scope,
+            payload: registration,
+        }), isRuntimeRegisterContributionResult, RUNTIME_CONTRIBUTION_RESULT_ERROR),
+        unregisterContribution: async (scope, unregistration) => toDecodedOperationResult(await invoke({
+            capability: OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.RUNTIME,
+            method: OPENWAGGLE_EXTENSION_BROKER.METHOD.UNREGISTER_CONTRIBUTION,
+            scope,
+            payload: unregistration,
+        }), isRuntimeUnregisterContributionResult, RUNTIME_CONTRIBUTION_RESULT_ERROR),
+    };
+}

package/dist/runtime-types.d.ts

@@ -0,0 +1,19 @@
+import type { OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+import type { ExtensionContributionFamily } from './contribution-types.js';
+export interface ExtensionRuntimeRegisterContributionResult {
+    readonly extensionId: string;
+    readonly contributionId: string;
+    readonly capability: typeof OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.RUNTIME;
+    readonly method: typeof OPENWAGGLE_EXTENSION_BROKER.METHOD.REGISTER_CONTRIBUTION;
+    readonly family: ExtensionContributionFamily;
+    readonly registeredContributionId: string;
+}
+export interface ExtensionRuntimeUnregisterContributionResult {
+    readonly extensionId: string;
+    readonly contributionId: string;
+    readonly capability: typeof OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.RUNTIME;
+    readonly method: typeof OPENWAGGLE_EXTENSION_BROKER.METHOD.UNREGISTER_CONTRIBUTION;
+    readonly family: ExtensionContributionFamily;
+    readonly unregisteredContributionId: string;
+    readonly unregistered: boolean;
+}

package/dist/runtime-types.js

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

package/dist/runtime.d.ts

@@ -0,0 +1,22 @@
+import * as Schema from 'effect/Schema';
+export type { ExtensionContributionRegistration, ExtensionContributionUnregistration, } from './manifest.js';
+export { extensionContributionRegistrationSchema, extensionContributionUnregistrationSchema, } from './manifest.js';
+export { createRuntimeContributionSdk } from './runtime-sdk.js';
+export type * from './runtime-types.js';
+export declare const extensionRuntimeRegisterContributionResultSchema: Schema.Struct<{
+    extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    capability: Schema.Literal<["openwaggle.runtime"]>;
+    method: Schema.Literal<["register-contribution"]>;
+    family: Schema.Literal<["commands", "slashCommands", "routes", "settingsSections", "sidePanels", "dialogs", "transcriptRenderers", "toolRenderers", "customMessageRenderers", "interactionRenderers", "statusWidgets"]>;
+    registeredContributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+}>;
+export declare const extensionRuntimeUnregisterContributionResultSchema: Schema.Struct<{
+    extensionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    contributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    capability: Schema.Literal<["openwaggle.runtime"]>;
+    method: Schema.Literal<["unregister-contribution"]>;
+    family: Schema.Literal<["commands", "slashCommands", "routes", "settingsSections", "sidePanels", "dialogs", "transcriptRenderers", "toolRenderers", "customMessageRenderers", "interactionRenderers", "statusWidgets"]>;
+    unregisteredContributionId: Schema.filter<Schema.filter<typeof Schema.String>>;
+    unregistered: typeof Schema.Boolean;
+}>;

package/dist/runtime.js

@@ -0,0 +1,22 @@
+import * as Schema from 'effect/Schema';
+import { OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+import { extensionContributionFamilySchema, extensionContributionIdSchema, extensionIdSchema, } from './manifest.js';
+export { extensionContributionRegistrationSchema, extensionContributionUnregistrationSchema, } from './manifest.js';
+export { createRuntimeContributionSdk } from './runtime-sdk.js';
+export const extensionRuntimeRegisterContributionResultSchema = Schema.Struct({
+    extensionId: extensionIdSchema,
+    contributionId: extensionContributionIdSchema,
+    capability: Schema.Literal(OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.RUNTIME),
+    method: Schema.Literal(OPENWAGGLE_EXTENSION_BROKER.METHOD.REGISTER_CONTRIBUTION),
+    family: extensionContributionFamilySchema,
+    registeredContributionId: extensionContributionIdSchema,
+});
+export const extensionRuntimeUnregisterContributionResultSchema = Schema.Struct({
+    extensionId: extensionIdSchema,
+    contributionId: extensionContributionIdSchema,
+    capability: Schema.Literal(OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.RUNTIME),
+    method: Schema.Literal(OPENWAGGLE_EXTENSION_BROKER.METHOD.UNREGISTER_CONTRIBUTION),
+    family: extensionContributionFamilySchema,
+    unregisteredContributionId: extensionContributionIdSchema,
+    unregistered: Schema.Boolean,
+});

package/dist/schema.d.ts

@@ -0,0 +1,13 @@
+import type * as Schema from 'effect/Schema';
+type AnySchema = Schema.Schema.AnyNoContext;
+export type SchemaType<TSchema extends AnySchema> = Schema.Schema.Type<TSchema>;
+export interface ExtensionSchemaDecodeSuccess<TValue> {
+    readonly success: true;
+    readonly data: TValue;
+}
+export interface ExtensionSchemaDecodeFailure {
+    readonly success: false;
+    readonly issues: readonly string[];
+}
+export declare function safeDecodeExtensionSchema<TValue, TEncoded>(schema: Schema.Schema<TValue, TEncoded, never>, value: unknown): ExtensionSchemaDecodeSuccess<TValue> | ExtensionSchemaDecodeFailure;
+export {};

package/dist/schema.js

@@ -0,0 +1,25 @@
+import * as ParseResult from 'effect/ParseResult';
+function formatIssuePath(path) {
+    const joinedPath = path.map(String).join('.');
+    return joinedPath.length > 0 ? joinedPath : '(root)';
+}
+function formatParseError(error) {
+    return ParseResult.ArrayFormatter.formatErrorSync(error).map((issue) => `${formatIssuePath(issue.path)}: ${issue.message}`);
+}
+export function safeDecodeExtensionSchema(schema, value) {
+    try {
+        return {
+            success: true,
+            data: ParseResult.decodeUnknownSync(schema)(value),
+        };
+    }
+    catch (error) {
+        if (ParseResult.isParseError(error)) {
+            return {
+                success: false,
+                issues: formatParseError(error),
+            };
+        }
+        throw error;
+    }
+}

package/dist/sdk-types.d.ts

@@ -0,0 +1,92 @@
+import type { JsonValue } from './json.js';
+import type { ExtensionActionSelectProjectResult, ExtensionDocsDiscoverPayload, ExtensionDocsDiscoverResult, ExtensionDocsResolveTopicPayload, ExtensionDocsResolveTopicResult, ExtensionInvokeFailure, ExtensionInvokeInput, ExtensionInvokeResult, ExtensionInvokeScope, ExtensionInvokeSuccess, ExtensionModelPreferencesSettingsPatch, ExtensionRuntimeRegisterContributionPayload, ExtensionRuntimeRegisterContributionResult, ExtensionRuntimeUnregisterContributionPayload, ExtensionRuntimeUnregisterContributionResult, ExtensionSettingsGetResult, ExtensionSettingsGetSettingResult, ExtensionSettingsUpdatePayload, ExtensionSettingsUpdateResult, ExtensionSettingsUpdateSettingResult, ExtensionStateCurrentBranchReadResult, ExtensionStateCurrentProjectReadResult, ExtensionStateCurrentSessionReadResult, ExtensionStateModelPreferencesReadResult, ExtensionStateReadResult, ExtensionStateRecentProjectsReadResult, ExtensionStorageDeleteResult, ExtensionStorageGetResult, ExtensionStorageListResult, ExtensionStorageSetResult } from './types.js';
+export type ExtensionOperationSuccess<TValue> = ExtensionInvokeSuccess<TValue>;
+export type ExtensionStorageGetOperationResult = ExtensionOperationSuccess<ExtensionStorageGetResult> | ExtensionInvokeFailure;
+export type ExtensionStorageSetOperationResult = ExtensionOperationSuccess<ExtensionStorageSetResult> | ExtensionInvokeFailure;
+export type ExtensionStorageDeleteOperationResult = ExtensionOperationSuccess<ExtensionStorageDeleteResult> | ExtensionInvokeFailure;
+export type ExtensionStorageListOperationResult = ExtensionOperationSuccess<ExtensionStorageListResult> | ExtensionInvokeFailure;
+export type ExtensionRuntimeRegisterContributionOperationResult = ExtensionOperationSuccess<ExtensionRuntimeRegisterContributionResult> | ExtensionInvokeFailure;
+export type ExtensionRuntimeUnregisterContributionOperationResult = ExtensionOperationSuccess<ExtensionRuntimeUnregisterContributionResult> | ExtensionInvokeFailure;
+export type ExtensionStateReadOperationResult = ExtensionOperationSuccess<ExtensionStateReadResult> | ExtensionInvokeFailure;
+export type ExtensionStateCurrentProjectReadOperationResult = ExtensionOperationSuccess<ExtensionStateCurrentProjectReadResult> | ExtensionInvokeFailure;
+export type ExtensionStateCurrentSessionReadOperationResult = ExtensionOperationSuccess<ExtensionStateCurrentSessionReadResult> | ExtensionInvokeFailure;
+export type ExtensionStateCurrentBranchReadOperationResult = ExtensionOperationSuccess<ExtensionStateCurrentBranchReadResult> | ExtensionInvokeFailure;
+export type ExtensionStateRecentProjectsReadOperationResult = ExtensionOperationSuccess<ExtensionStateRecentProjectsReadResult> | ExtensionInvokeFailure;
+export type ExtensionStateModelPreferencesReadOperationResult = ExtensionOperationSuccess<ExtensionStateModelPreferencesReadResult> | ExtensionInvokeFailure;
+export type ExtensionSelectProjectOperationResult = ExtensionOperationSuccess<ExtensionActionSelectProjectResult> | ExtensionInvokeFailure;
+export type ExtensionDocsDiscoverOperationResult = ExtensionOperationSuccess<ExtensionDocsDiscoverResult> | ExtensionInvokeFailure;
+export type ExtensionDocsResolveTopicOperationResult = ExtensionOperationSuccess<ExtensionDocsResolveTopicResult> | ExtensionInvokeFailure;
+export type ExtensionSettingsGetOperationResult = ExtensionOperationSuccess<ExtensionSettingsGetResult> | ExtensionInvokeFailure;
+export type ExtensionSettingsGetSettingOperationResult = ExtensionOperationSuccess<ExtensionSettingsGetSettingResult> | ExtensionInvokeFailure;
+export type ExtensionSettingsUpdateOperationResult = ExtensionOperationSuccess<ExtensionSettingsUpdateResult> | ExtensionInvokeFailure;
+export type ExtensionSettingsUpdateSettingOperationResult = ExtensionOperationSuccess<ExtensionSettingsUpdateSettingResult> | ExtensionInvokeFailure;
+export interface ExtensionSdkIdentity {
+    readonly extensionId: string;
+    readonly contributionId: string;
+}
+export interface ExtensionSdkInvokeRequest {
+    readonly capability: string;
+    readonly method: string;
+    readonly scope: ExtensionInvokeScope;
+    readonly payload?: unknown;
+}
+export type ExtensionBrokerTransport = (input: ExtensionInvokeInput) => Promise<ExtensionInvokeResult>;
+export type ExtensionSdkInvoke = (request: ExtensionSdkInvokeRequest) => Promise<ExtensionInvokeResult>;
+export interface ExtensionStorageScopeSdk {
+    readonly get: (scope: ExtensionInvokeScope, key: string) => Promise<ExtensionInvokeResult<ExtensionStorageGetResult>>;
+    readonly set: (scope: ExtensionInvokeScope, key: string, value: JsonValue) => Promise<ExtensionInvokeResult<ExtensionStorageSetResult>>;
+    readonly delete: (scope: ExtensionInvokeScope, key: string) => Promise<ExtensionInvokeResult<ExtensionStorageDeleteResult>>;
+    readonly list: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionStorageListResult>>;
+}
+export interface ExtensionPackageStorageKindSdk {
+    readonly global: ExtensionStorageScopeSdk;
+    readonly project: ExtensionStorageScopeSdk;
+}
+export interface ExtensionPackageStorageSdk {
+    readonly packageState: ExtensionPackageStorageKindSdk;
+    readonly packageConfig: ExtensionPackageStorageKindSdk;
+}
+export interface ExtensionOpenWaggleStateSdk {
+    readonly get: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionStateReadResult>>;
+    readonly readCurrentProject: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionStateCurrentProjectReadResult>>;
+    readonly readCurrentSession: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionStateCurrentSessionReadResult>>;
+    readonly readCurrentBranch: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionStateCurrentBranchReadResult>>;
+    readonly readRecentProjects: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionStateRecentProjectsReadResult>>;
+    readonly readModelPreferences: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionStateModelPreferencesReadResult>>;
+}
+export interface ExtensionOpenWaggleSettingsSdk {
+    readonly get: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionSettingsGetResult>>;
+    readonly getModelPreferences: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult<ExtensionSettingsGetSettingResult>>;
+    readonly updateModelPreferences: (scope: ExtensionInvokeScope, value: ExtensionModelPreferencesSettingsPatch) => Promise<ExtensionInvokeResult<ExtensionSettingsUpdateSettingResult>>;
+    readonly getProjectDisplayName: (scope: ExtensionInvokeScope, projectPath: string) => Promise<ExtensionInvokeResult<ExtensionSettingsGetSettingResult>>;
+    readonly setProjectDisplayName: (scope: ExtensionInvokeScope, projectPath: string, value: string | null) => Promise<ExtensionInvokeResult<ExtensionSettingsUpdateSettingResult>>;
+    readonly update: (scope: ExtensionInvokeScope, settings: ExtensionSettingsUpdatePayload) => Promise<ExtensionInvokeResult<ExtensionSettingsUpdateResult>>;
+}
+export interface ExtensionOpenWaggleSdk {
+    readonly state: ExtensionOpenWaggleStateSdk;
+    readonly actions: {
+        readonly selectProject: (scope: ExtensionInvokeScope, projectPath: string) => Promise<ExtensionInvokeResult<ExtensionActionSelectProjectResult>>;
+        readonly openExternal: (url: string) => Promise<void>;
+    };
+    readonly settings: ExtensionOpenWaggleSettingsSdk;
+    readonly docs: {
+        readonly discover: (scope: ExtensionInvokeScope, input?: ExtensionDocsDiscoverPayload) => Promise<ExtensionInvokeResult<ExtensionDocsDiscoverResult>>;
+        readonly resolveTopic: (scope: ExtensionInvokeScope, input: ExtensionDocsResolveTopicPayload) => Promise<ExtensionInvokeResult<ExtensionDocsResolveTopicResult>>;
+    };
+}
+export interface ExtensionRuntimeContributionSdk {
+    readonly registerContribution: (scope: ExtensionInvokeScope, registration: ExtensionRuntimeRegisterContributionPayload) => Promise<ExtensionInvokeResult<ExtensionRuntimeRegisterContributionResult>>;
+    readonly unregisterContribution: (scope: ExtensionInvokeScope, unregistration: ExtensionRuntimeUnregisterContributionPayload) => Promise<ExtensionInvokeResult<ExtensionRuntimeUnregisterContributionResult>>;
+}
+export interface ExtensionBrokerSdk {
+    readonly invoke: ExtensionSdkInvoke;
+    readonly hostContext: {
+        readonly getScope: (scope: ExtensionInvokeScope) => Promise<ExtensionInvokeResult>;
+    };
+    readonly storage: ExtensionPackageStorageSdk;
+    readonly openWaggle: ExtensionOpenWaggleSdk;
+    readonly runtime: ExtensionRuntimeContributionSdk;
+}
+export interface CreateOpenWaggleSdkOptions {
+    readonly openExternal?: (url: string) => Promise<void>;
+}

package/dist/sdk-types.js

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

package/dist/storage-sdk.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionPackageStorageSdk, ExtensionSdkInvoke } from './sdk-types.js';
+export declare function createPackageStorageSdk(invoke: ExtensionSdkInvoke): ExtensionPackageStorageSdk;

package/dist/storage-sdk.js

@@ -0,0 +1,51 @@
+import { isStorageDeleteResult, isStorageGetResult, isStorageListResult, isStorageSetResult, toDecodedOperationResult, } from './broker-validation.js';
+import { OPENWAGGLE_EXTENSION, OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+const STORAGE_RESULT_ERROR = 'Extension broker returned an invalid storage result.';
+function storagePayload(storageKind, storageScope, key, value) {
+    return {
+        storageKind,
+        storageScope,
+        ...(key !== undefined ? { key } : {}),
+        ...(value !== undefined ? { value } : {}),
+    };
+}
+function createStorageScopeSdk(invoke, storageKind, storageScope) {
+    return {
+        get: async (scope, key) => toDecodedOperationResult(await invoke({
+            capability: OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STORAGE,
+            method: OPENWAGGLE_EXTENSION_BROKER.METHOD.GET,
+            scope,
+            payload: storagePayload(storageKind, storageScope, key),
+        }), isStorageGetResult, STORAGE_RESULT_ERROR),
+        set: async (scope, key, value) => toDecodedOperationResult(await invoke({
+            capability: OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STORAGE,
+            method: OPENWAGGLE_EXTENSION_BROKER.METHOD.SET,
+            scope,
+            payload: storagePayload(storageKind, storageScope, key, value),
+        }), isStorageSetResult, STORAGE_RESULT_ERROR),
+        delete: async (scope, key) => toDecodedOperationResult(await invoke({
+            capability: OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STORAGE,
+            method: OPENWAGGLE_EXTENSION_BROKER.METHOD.DELETE,
+            scope,
+            payload: storagePayload(storageKind, storageScope, key),
+        }), isStorageDeleteResult, STORAGE_RESULT_ERROR),
+        list: async (scope) => toDecodedOperationResult(await invoke({
+            capability: OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STORAGE,
+            method: OPENWAGGLE_EXTENSION_BROKER.METHOD.LIST,
+            scope,
+            payload: storagePayload(storageKind, storageScope),
+        }), isStorageListResult, STORAGE_RESULT_ERROR),
+    };
+}
+function createStorageKindSdk(invoke, storageKind) {
+    return {
+        global: createStorageScopeSdk(invoke, storageKind, OPENWAGGLE_EXTENSION.STORAGE.SCOPE.GLOBAL_KIND),
+        project: createStorageScopeSdk(invoke, storageKind, OPENWAGGLE_EXTENSION.STORAGE.SCOPE.PROJECT_KIND),
+    };
+}
+export function createPackageStorageSdk(invoke) {
+    return {
+        packageState: createStorageKindSdk(invoke, OPENWAGGLE_EXTENSION.STORAGE.KIND.STATE),
+        packageConfig: createStorageKindSdk(invoke, OPENWAGGLE_EXTENSION.STORAGE.KIND.CONFIG),
+    };
+}

package/dist/storage-types.d.ts

@@ -0,0 +1,40 @@
+import type { OPENWAGGLE_EXTENSION, OPENWAGGLE_EXTENSION_BROKER } from './constants.js';
+import type { JsonValue } from './json.js';
+type ConstantValue<TObject> = TObject[keyof TObject];
+export type ExtensionStorageKind = ConstantValue<typeof OPENWAGGLE_EXTENSION.STORAGE.KIND>;
+export type ExtensionStorageScopeSelector = (typeof OPENWAGGLE_EXTENSION.STORAGE.SCOPE_KINDS)[number];
+export type ExtensionStorageScope = {
+    readonly kind: typeof OPENWAGGLE_EXTENSION.STORAGE.SCOPE.GLOBAL_KIND;
+} | {
+    readonly kind: typeof OPENWAGGLE_EXTENSION.STORAGE.SCOPE.PROJECT_KIND;
+    readonly projectPath: string;
+};
+export interface ExtensionStorageResultBase {
+    readonly extensionId: string;
+    readonly contributionId: string;
+    readonly capability: typeof OPENWAGGLE_EXTENSION_BROKER.CAPABILITY.STORAGE;
+    readonly storageKind: ExtensionStorageKind;
+    readonly storageScope: ExtensionStorageScope;
+}
+export interface ExtensionStorageGetResult extends ExtensionStorageResultBase {
+    readonly method: typeof OPENWAGGLE_EXTENSION_BROKER.METHOD.GET;
+    readonly key: string;
+    readonly value: JsonValue | null;
+}
+export interface ExtensionStorageSetResult extends ExtensionStorageResultBase {
+    readonly method: typeof OPENWAGGLE_EXTENSION_BROKER.METHOD.SET;
+    readonly key: string;
+    readonly value: JsonValue;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface ExtensionStorageDeleteResult extends ExtensionStorageResultBase {
+    readonly method: typeof OPENWAGGLE_EXTENSION_BROKER.METHOD.DELETE;
+    readonly key: string;
+    readonly deleted: true;
+}
+export interface ExtensionStorageListResult extends ExtensionStorageResultBase {
+    readonly method: typeof OPENWAGGLE_EXTENSION_BROKER.METHOD.LIST;
+    readonly keys: readonly string[];
+}
+export {};

package/dist/storage-types.js

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

package/dist/theme-data.d.ts

@@ -0,0 +1,126 @@
+export declare const OPENWAGGLE_EXTENSION_THEME_CSS_VARIABLES: {
+    readonly color: {
+        readonly background: "--ow-color-background";
+        readonly surface: "--ow-color-surface";
+        readonly surfaceRaised: "--ow-color-surface-raised";
+        readonly surfaceHover: "--ow-color-surface-hover";
+        readonly surfaceActive: "--ow-color-surface-active";
+        readonly border: "--ow-color-border";
+        readonly borderStrong: "--ow-color-border-strong";
+        readonly text: "--ow-color-text";
+        readonly textSubtle: "--ow-color-text-subtle";
+        readonly textMuted: "--ow-color-text-muted";
+        readonly textDim: "--ow-color-text-dim";
+        readonly accent: "--ow-color-accent";
+        readonly accentDim: "--ow-color-accent-dim";
+        readonly success: "--ow-color-success";
+        readonly danger: "--ow-color-danger";
+        readonly warning: "--ow-color-warning";
+        readonly info: "--ow-color-info";
+    };
+    readonly typography: {
+        readonly sansFamily: "--ow-font-family-sans";
+        readonly monoFamily: "--ow-font-family-mono";
+    };
+    readonly spacing: {
+        readonly xs: "--ow-space-xs";
+        readonly sm: "--ow-space-sm";
+        readonly md: "--ow-space-md";
+        readonly lg: "--ow-space-lg";
+        readonly xl: "--ow-space-xl";
+    };
+    readonly radius: {
+        readonly sm: "--ow-radius-sm";
+        readonly md: "--ow-radius-md";
+        readonly lg: "--ow-radius-lg";
+        readonly panel: "--ow-radius-panel";
+    };
+    readonly focus: {
+        readonly ring: "--ow-focus-ring";
+        readonly shadow: "--ow-focus-shadow";
+    };
+    readonly elevation: {
+        readonly card: "--ow-elevation-card";
+        readonly overlay: "--ow-elevation-overlay";
+    };
+};
+export declare const DEFAULT_EXTENSION_THEME_TOKENS: {
+    readonly color: {
+        readonly background: "#141619";
+        readonly surface: "#1a1d22";
+        readonly surfaceRaised: "#1f232a";
+        readonly surfaceHover: "#262b33";
+        readonly surfaceActive: "#1d1a10";
+        readonly border: "#1e2229";
+        readonly borderStrong: "#2a3240";
+        readonly text: "#e7e9ee";
+        readonly textSubtle: "#c9cdd6";
+        readonly textMuted: "#9098a8";
+        readonly textDim: "#666f7d";
+        readonly accent: "#f5a623";
+        readonly accentDim: "#b87410";
+        readonly success: "#4caf72";
+        readonly danger: "#ef4444";
+        readonly warning: "#f5a623";
+        readonly info: "#61a8ff";
+    };
+    readonly typography: {
+        readonly sansFamily: "Inter, \"SF Pro Text\", \"SF Pro Display\", -apple-system, BlinkMacSystemFont, \"Segoe UI\", sans-serif";
+        readonly monoFamily: "\"SF Mono\", \"JetBrains Mono\", \"Cascadia Mono\", ui-monospace, monospace";
+    };
+    readonly spacing: {
+        readonly xs: "4px";
+        readonly sm: "8px";
+        readonly md: "12px";
+        readonly lg: "16px";
+        readonly xl: "24px";
+    };
+    readonly radius: {
+        readonly sm: "6px";
+        readonly md: "9px";
+        readonly lg: "12px";
+        readonly panel: "22px";
+    };
+    readonly focus: {
+        readonly ring: "#9aa3b2";
+        readonly shadow: "0 0 0 1px color-mix(in srgb, #9aa3b2 76%, transparent), 0 0 0 3px color-mix(in srgb, #9aa3b2 15%, transparent)";
+    };
+    readonly elevation: {
+        readonly card: "inset 0 1px 0 rgba(255, 255, 255, 0.02)";
+        readonly overlay: "0 24px 80px rgba(0, 0, 0, 0.45)";
+    };
+};
+export declare const SOURCE_EXTENSION_THEME_CSS_VARIABLES: {
+    readonly color: {
+        readonly background: "--color-bg";
+        readonly surface: "--color-bg-secondary";
+        readonly surfaceRaised: "--color-bg-tertiary";
+        readonly surfaceHover: "--color-bg-hover";
+        readonly surfaceActive: "--color-bg-active";
+        readonly border: "--color-border";
+        readonly borderStrong: "--color-border-light";
+        readonly text: "--color-text-primary";
+        readonly textSubtle: "--color-text-secondary";
+        readonly textMuted: "--color-text-tertiary";
+        readonly textDim: "--color-text-muted";
+        readonly accent: "--color-accent";
+        readonly accentDim: "--color-accent-dim";
+        readonly success: "--color-success";
+        readonly danger: "--color-error";
+        readonly warning: "--color-warning";
+        readonly info: "--color-info";
+    };
+    readonly typography: {
+        readonly sansFamily: "--font-sans";
+        readonly monoFamily: "--font-mono";
+    };
+    readonly radius: {
+        readonly panel: "--radius-panel";
+    };
+};
+export declare const EXTENSION_THEME_COLOR_KEYS: readonly ["background", "surface", "surfaceRaised", "surfaceHover", "surfaceActive", "border", "borderStrong", "text", "textSubtle", "textMuted", "textDim", "accent", "accentDim", "success", "danger", "warning", "info"];
+export declare const EXTENSION_THEME_TYPOGRAPHY_KEYS: readonly ["sansFamily", "monoFamily"];
+export declare const EXTENSION_THEME_SPACING_KEYS: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const EXTENSION_THEME_RADIUS_KEYS: readonly ["sm", "md", "lg", "panel"];
+export declare const EXTENSION_THEME_FOCUS_KEYS: readonly ["ring", "shadow"];
+export declare const EXTENSION_THEME_ELEVATION_KEYS: readonly ["card", "overlay"];