@superpanel-sdk/runtime 0.0.1-internal.1

package/dist/core/context/hubspot.d.ts

@@ -0,0 +1,250 @@
+import { z } from 'zod';
+import type { IntegrationAccountFields } from './account-fields.js';
+export declare const hubspotPropertyValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+export declare const hubspotPropertiesInput: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+export declare const hubspotPropertiesOutput: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+export declare const hubspotRecord: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotRecord = z.infer<typeof hubspotRecord>;
+export declare const hubspotCreateContactInput: z.ZodObject<{
+    properties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type HubspotCreateContactInput = z.infer<typeof hubspotCreateContactInput>;
+export declare const hubspotCreateContactOutput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotCreateContactOutput = HubspotRecord;
+export declare const hubspotUpdateContactInput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type HubspotUpdateContactInput = z.infer<typeof hubspotUpdateContactInput>;
+export declare const hubspotUpdateContactOutput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotUpdateContactOutput = HubspotRecord;
+export declare const hubspotGetContactInput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotGetContactInput = z.infer<typeof hubspotGetContactInput>;
+export declare const hubspotGetContactOutput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotGetContactOutput = HubspotRecord;
+export declare const hubspotSearchContactsInput: z.ZodObject<{
+    query: z.ZodString;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HubspotSearchContactsInput = z.infer<typeof hubspotSearchContactsInput>;
+export declare const hubspotSearchContactsOutput: z.ZodObject<{
+    total: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HubspotSearchContactsOutput = z.infer<typeof hubspotSearchContactsOutput>;
+export declare const hubspotUpsertContactInput: z.ZodObject<{
+    email: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, z.core.$strip>;
+export type HubspotUpsertContactInput = z.infer<typeof hubspotUpsertContactInput>;
+export declare const hubspotUpsertContactOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    id: z.ZodString;
+    created: z.ZodBoolean;
+}, z.core.$strip>;
+export type HubspotUpsertContactOutput = z.infer<typeof hubspotUpsertContactOutput>;
+export declare const hubspotCreateDealInput: z.ZodObject<{
+    properties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    contactId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HubspotCreateDealInput = z.infer<typeof hubspotCreateDealInput>;
+export declare const hubspotCreateDealOutput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotCreateDealOutput = HubspotRecord;
+export declare const hubspotUpdateDealInput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strip>;
+export type HubspotUpdateDealInput = z.infer<typeof hubspotUpdateDealInput>;
+export declare const hubspotUpdateDealOutput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotUpdateDealOutput = HubspotRecord;
+export declare const hubspotGetDealInput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotGetDealInput = z.infer<typeof hubspotGetDealInput>;
+export declare const hubspotGetDealOutput: z.ZodObject<{
+    id: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type HubspotGetDealOutput = HubspotRecord;
+export declare const hubspotGetAssociatedDealsInput: z.ZodObject<{
+    contactId: z.ZodString;
+}, z.core.$strip>;
+export type HubspotGetAssociatedDealsInput = z.infer<typeof hubspotGetAssociatedDealsInput>;
+export declare const hubspotAssociationListOutput: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type HubspotAssociationListOutput = z.infer<typeof hubspotAssociationListOutput>;
+export declare const hubspotGetAssociatedContactsInput: z.ZodObject<{
+    dealId: z.ZodString;
+}, z.core.$strip>;
+export type HubspotGetAssociatedContactsInput = z.infer<typeof hubspotGetAssociatedContactsInput>;
+export declare const hubspotGetOwnerInput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type HubspotGetOwnerInput = z.infer<typeof hubspotGetOwnerInput>;
+export declare const hubspotGetOwnerOutput: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    firstName: z.ZodNullable<z.ZodString>;
+    lastName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type HubspotGetOwnerOutput = z.infer<typeof hubspotGetOwnerOutput>;
+export declare const hubspotCreateNoteInput: z.ZodObject<{
+    contactId: z.ZodString;
+    body: z.ZodString;
+}, z.core.$strip>;
+export type HubspotCreateNoteInput = z.infer<typeof hubspotCreateNoteInput>;
+export declare const hubspotEngagementOutput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type HubspotEngagementOutput = z.infer<typeof hubspotEngagementOutput>;
+export declare const hubspotLogCallInput: z.ZodObject<{
+    to: z.ZodObject<{
+        kind: z.ZodEnum<{
+            contact: "contact";
+            deal: "deal";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    direction: z.ZodEnum<{
+        INBOUND: "INBOUND";
+        OUTBOUND: "OUTBOUND";
+    }>;
+    timestamp: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    recordingUrl: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        BUSY: "BUSY";
+        CALLING_CRM_USER: "CALLING_CRM_USER";
+        CANCELED: "CANCELED";
+        COMPLETED: "COMPLETED";
+        CONNECTING: "CONNECTING";
+        FAILED: "FAILED";
+        IN_PROGRESS: "IN_PROGRESS";
+        NO_ANSWER: "NO_ANSWER";
+        QUEUED: "QUEUED";
+        RINGING: "RINGING";
+    }>>;
+}, z.core.$strip>;
+export type HubspotLogCallInput = z.infer<typeof hubspotLogCallInput>;
+export declare const hubspotLogEmailInput: z.ZodObject<{
+    to: z.ZodObject<{
+        kind: z.ZodEnum<{
+            contact: "contact";
+            deal: "deal";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    direction: z.ZodEnum<{
+        EMAIL: "EMAIL";
+        FORWARDED_EMAIL: "FORWARDED_EMAIL";
+        INCOMING_EMAIL: "INCOMING_EMAIL";
+    }>;
+    subject: z.ZodString;
+    body: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type HubspotLogEmailInput = z.infer<typeof hubspotLogEmailInput>;
+export declare const hubspotLogSmsInput: z.ZodObject<{
+    to: z.ZodObject<{
+        kind: z.ZodEnum<{
+            contact: "contact";
+            deal: "deal";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    message: z.ZodString;
+    timestamp: z.ZodNumber;
+    prefix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HubspotLogSmsInput = z.infer<typeof hubspotLogSmsInput>;
+export declare const hubspotCreateTaskInput: z.ZodObject<{
+    to: z.ZodObject<{
+        kind: z.ZodEnum<{
+            contact: "contact";
+            deal: "deal";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    title: z.ZodString;
+    description: z.ZodString;
+    dueAt: z.ZodNumber;
+    ownerId: z.ZodString;
+    priority: z.ZodEnum<{
+        HIGH: "HIGH";
+        LOW: "LOW";
+        MEDIUM: "MEDIUM";
+    }>;
+    status: z.ZodEnum<{
+        COMPLETED: "COMPLETED";
+        DEFERRED: "DEFERRED";
+        IN_PROGRESS: "IN_PROGRESS";
+        NOT_STARTED: "NOT_STARTED";
+        WAITING: "WAITING";
+    }>;
+}, z.core.$strip>;
+export type HubspotCreateTaskInput = z.infer<typeof hubspotCreateTaskInput>;
+export declare const hubspotGetCrmUrlInput: z.ZodObject<{
+    type: z.ZodEnum<{
+        call: "call";
+        contact: "contact";
+    }>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type HubspotGetCrmUrlInput = z.infer<typeof hubspotGetCrmUrlInput>;
+export declare const hubspotGetCrmUrlOutput: z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>;
+export type HubspotGetCrmUrlOutput = z.infer<typeof hubspotGetCrmUrlOutput>;
+export type HubspotService = {
+    createContact(input: HubspotCreateContactInput): Promise<HubspotCreateContactOutput>;
+    updateContact(input: HubspotUpdateContactInput): Promise<HubspotUpdateContactOutput>;
+    getContact(input: HubspotGetContactInput): Promise<HubspotGetContactOutput>;
+    searchContacts(input: HubspotSearchContactsInput): Promise<HubspotSearchContactsOutput>;
+    upsertContact(input: HubspotUpsertContactInput): Promise<HubspotUpsertContactOutput>;
+    createDeal(input: HubspotCreateDealInput): Promise<HubspotCreateDealOutput>;
+    updateDeal(input: HubspotUpdateDealInput): Promise<HubspotUpdateDealOutput>;
+    getDeal(input: HubspotGetDealInput): Promise<HubspotGetDealOutput>;
+    getAssociatedDeals(input: HubspotGetAssociatedDealsInput): Promise<HubspotAssociationListOutput>;
+    getAssociatedContacts(input: HubspotGetAssociatedContactsInput): Promise<HubspotAssociationListOutput>;
+    getOwner(input: HubspotGetOwnerInput): Promise<HubspotGetOwnerOutput>;
+    createNote(input: HubspotCreateNoteInput): Promise<HubspotEngagementOutput>;
+    logCall(input: HubspotLogCallInput): Promise<HubspotEngagementOutput>;
+    logEmail(input: HubspotLogEmailInput): Promise<HubspotEngagementOutput>;
+    logSms(input: HubspotLogSmsInput): Promise<HubspotEngagementOutput>;
+    createTask(input: HubspotCreateTaskInput): Promise<HubspotEngagementOutput>;
+    getCrmUrl(input: HubspotGetCrmUrlInput): Promise<HubspotGetCrmUrlOutput>;
+};
+export declare const hubspotMockService: HubspotService;
+export type HubspotApi = IntegrationAccountFields & HubspotService;
+//# sourceMappingURL=hubspot.d.ts.map

package/dist/core/context/hubspot.js

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+export const hubspotPropertyValue = z.union([z.string(), z.number(), z.boolean()]);
+export const hubspotPropertiesInput = z.record(z.string(), hubspotPropertyValue);
+export const hubspotPropertiesOutput = z.record(z.string(), z.string().nullable());
+export const hubspotRecord = z.object({
+    id: z.string(),
+    properties: hubspotPropertiesOutput,
+});
+export const hubspotCreateContactInput = z.object({
+    properties: hubspotPropertiesInput,
+});
+export const hubspotCreateContactOutput = hubspotRecord;
+export const hubspotUpdateContactInput = z.object({
+    id: z.string(),
+    properties: hubspotPropertiesInput,
+});
+export const hubspotUpdateContactOutput = hubspotRecord;
+export const hubspotGetContactInput = z.object({
+    id: z.string(),
+    properties: z.array(z.string()).optional(),
+});
+export const hubspotGetContactOutput = hubspotRecord;
+export const hubspotSearchContactsInput = z.object({
+    query: z.string(),
+    properties: z.array(z.string()).optional(),
+    after: z.string().optional(),
+});
+export const hubspotSearchContactsOutput = z.object({
+    total: z.number(),
+    results: z.array(hubspotRecord),
+    after: z.string().optional(),
+});
+export const hubspotUpsertContactInput = z.object({
+    email: z.string(),
+    properties: hubspotPropertiesInput.optional(),
+});
+export const hubspotUpsertContactOutput = z.object({
+    ok: z.literal(true),
+    id: z.string(),
+    created: z.boolean(),
+});
+export const hubspotCreateDealInput = z.object({
+    properties: hubspotPropertiesInput,
+    contactId: z.string().optional(),
+});
+export const hubspotCreateDealOutput = hubspotRecord;
+export const hubspotUpdateDealInput = z.object({
+    id: z.string(),
+    properties: hubspotPropertiesInput,
+});
+export const hubspotUpdateDealOutput = hubspotRecord;
+export const hubspotGetDealInput = z.object({
+    id: z.string(),
+    properties: z.array(z.string()).optional(),
+});
+export const hubspotGetDealOutput = hubspotRecord;
+export const hubspotGetAssociatedDealsInput = z.object({
+    contactId: z.string(),
+});
+export const hubspotAssociationListOutput = z.object({
+    results: z.array(z.object({ id: z.string() })),
+});
+export const hubspotGetAssociatedContactsInput = z.object({
+    dealId: z.string(),
+});
+export const hubspotGetOwnerInput = z.object({
+    id: z.string(),
+});
+export const hubspotGetOwnerOutput = z.object({
+    id: z.string(),
+    email: z.string().nullable(),
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+});
+export const hubspotCreateNoteInput = z.object({
+    contactId: z.string(),
+    body: z.string(),
+});
+export const hubspotEngagementOutput = z.object({
+    id: z.string(),
+});
+const hubspotAssociateTo = z.object({
+    kind: z.enum(['contact', 'deal']),
+    id: z.string(),
+});
+export const hubspotLogCallInput = z.object({
+    to: hubspotAssociateTo,
+    direction: z.enum(['INBOUND', 'OUTBOUND']),
+    timestamp: z.number(),
+    title: z.string().optional(),
+    body: z.string().optional(),
+    recordingUrl: z.string().optional(),
+    status: z
+        .enum([
+        'BUSY',
+        'CALLING_CRM_USER',
+        'CANCELED',
+        'COMPLETED',
+        'CONNECTING',
+        'FAILED',
+        'IN_PROGRESS',
+        'NO_ANSWER',
+        'QUEUED',
+        'RINGING',
+    ])
+        .optional(),
+});
+export const hubspotLogEmailInput = z.object({
+    to: hubspotAssociateTo,
+    direction: z.enum(['EMAIL', 'INCOMING_EMAIL', 'FORWARDED_EMAIL']),
+    subject: z.string(),
+    body: z.string(),
+    timestamp: z.number(),
+});
+export const hubspotLogSmsInput = z.object({
+    to: hubspotAssociateTo,
+    message: z.string(),
+    timestamp: z.number(),
+    prefix: z.string().optional(),
+});
+export const hubspotCreateTaskInput = z.object({
+    to: hubspotAssociateTo,
+    title: z.string(),
+    description: z.string(),
+    dueAt: z.number(),
+    ownerId: z.string(),
+    priority: z.enum(['HIGH', 'MEDIUM', 'LOW']),
+    status: z.enum(['NOT_STARTED', 'IN_PROGRESS', 'WAITING', 'COMPLETED', 'DEFERRED']),
+});
+export const hubspotGetCrmUrlInput = z.object({
+    type: z.enum(['contact', 'call']),
+    id: z.string(),
+});
+export const hubspotGetCrmUrlOutput = z.object({
+    url: z.string(),
+});
+const mockRecord = { id: 'mock-hs-1', properties: {} };
+export const hubspotMockService = {
+    async createContact() {
+        return mockRecord;
+    },
+    async updateContact() {
+        return mockRecord;
+    },
+    async getContact() {
+        return mockRecord;
+    },
+    async searchContacts() {
+        return { total: 0, results: [] };
+    },
+    async upsertContact() {
+        return { ok: true, id: 'mock-hs-1', created: true };
+    },
+    async createDeal() {
+        return mockRecord;
+    },
+    async updateDeal() {
+        return mockRecord;
+    },
+    async getDeal() {
+        return mockRecord;
+    },
+    async getAssociatedDeals() {
+        return { results: [] };
+    },
+    async getAssociatedContacts() {
+        return { results: [] };
+    },
+    async getOwner() {
+        return { id: 'mock-owner', email: null, firstName: null, lastName: null };
+    },
+    async createNote() {
+        return { id: 'mock-note' };
+    },
+    async logCall() {
+        return { id: 'mock-call' };
+    },
+    async logEmail() {
+        return { id: 'mock-email' };
+    },
+    async logSms() {
+        return { id: 'mock-sms' };
+    },
+    async createTask() {
+        return { id: 'mock-task' };
+    },
+    async getCrmUrl() {
+        return { url: 'https://app.hubspot.com/contacts/0/record/0-1/mock-hs-1' };
+    },
+};
+//# sourceMappingURL=hubspot.js.map

package/dist/core/context/platform-registry.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Every platform API surface. Registering one here is what makes it appear on `ctx.api`,
+ * routable over RPC, and present in fake contexts — there is no second place to update.
+ */
+export declare const platformSurfaces: {
+    contact: {
+        methods: {
+            list: {
+                input: import("zod").ZodObject<{
+                    offset: import("zod").ZodNumber;
+                    limit: import("zod").ZodNumber;
+                    phone: import("zod").ZodOptional<import("zod").ZodString>;
+                    email: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                output: import("zod").ZodObject<{
+                    contacts: import("zod").ZodArray<import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        kind: import("zod").ZodString;
+                        externalIdentifier: import("zod").ZodNullable<import("zod").ZodString>;
+                        phone: import("zod").ZodNullable<import("zod").ZodString>;
+                        createdAt: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>>;
+                    offset: import("zod").ZodNumber;
+                    limit: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>;
+            };
+        };
+        mock: import("./contact.js").ContactApi;
+    };
+    db: {
+        methods: {
+            get: {
+                input: import("zod").ZodObject<{
+                    key: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                output: import("zod").ZodObject<{
+                    value: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+            };
+            set: {
+                input: import("zod").ZodObject<{
+                    key: import("zod").ZodString;
+                    value: import("zod").ZodString;
+                    ttlSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>;
+                output: import("zod").ZodObject<{
+                    ok: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strip>;
+            };
+            del: {
+                input: import("zod").ZodObject<{
+                    key: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                output: import("zod").ZodObject<{
+                    deleted: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>;
+            };
+        };
+        mock: import("./db.js").DbApi;
+    };
+};
+export type PlatformSurfaceKey = keyof typeof platformSurfaces;
+/** The platform half of `ctx.api`, derived so the registry stays the only source of truth. */
+export type PlatformApis = {
+    [K in PlatformSurfaceKey]: (typeof platformSurfaces)[K]['mock'];
+};
+//# sourceMappingURL=platform-registry.d.ts.map

package/dist/core/context/platform-registry.js

@@ -0,0 +1,11 @@
+import { contactSurface } from './contact.js';
+import { dbSurface } from './db.js';
+/**
+ * Every platform API surface. Registering one here is what makes it appear on `ctx.api`,
+ * routable over RPC, and present in fake contexts — there is no second place to update.
+ */
+export const platformSurfaces = {
+    contact: contactSurface,
+    db: dbSurface,
+};
+//# sourceMappingURL=platform-registry.js.map

package/dist/core/context/platform.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+/**
+ * Platform APIs (contact, company, case, ...) differ from integration APIs: their method set is
+ * fixed by this codebase rather than by whichever provider a sequence happens to be bound to.
+ * That makes them describable by a compile-time table, which drives RPC dispatch, server-side
+ * validation, the client stub and the fake context — so a new method is declared exactly once.
+ *
+ * Methods take a single params object; use `z.object({})` for the ones that need no input.
+ */
+export type PlatformApiShape = Record<string, (input: never) => Promise<unknown>>;
+export type PlatformSurface<TApi extends PlatformApiShape> = {
+    methods: {
+        [K in keyof TApi]: {
+            input: z.ZodType<Parameters<TApi[K]>[0]>;
+            output: z.ZodType<Awaited<ReturnType<TApi[K]>>>;
+        };
+    };
+    /** Stand-in used by fake contexts; its key set is also the surface's method list. */
+    mock: TApi;
+};
+/** Type-erased view used by registries and generic plumbing. */
+export type AnyPlatformSurface = {
+    methods: Record<string, {
+        input: z.ZodType;
+        output: z.ZodType;
+    }>;
+    mock: Record<string, (...args: never[]) => Promise<unknown>>;
+};
+/** Server-side implementation of one surface, checked against the surface's declared types. */
+export type PlatformImpl<TApi extends PlatformApiShape, TCtx> = {
+    [K in keyof TApi]: (ctx: TCtx, input: Parameters<TApi[K]>[0]) => ReturnType<TApi[K]>;
+};
+//# sourceMappingURL=platform.d.ts.map

package/dist/core/context/platform.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=platform.js.map

package/dist/core/context/twilio.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { IntegrationAccountFields } from './account-fields.js';
+export declare const twilioSendSmsInput: z.ZodObject<{
+    to: z.ZodString;
+    body: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TwilioSendSmsInput = z.infer<typeof twilioSendSmsInput>;
+export declare const twilioSendSmsOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    sid: z.ZodString;
+    status: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type TwilioSendSmsOutput = z.infer<typeof twilioSendSmsOutput>;
+export declare const twilioCreateCallInput: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    twiml: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TwilioCreateCallInput = z.infer<typeof twilioCreateCallInput>;
+export declare const twilioCreateCallOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    sid: z.ZodString;
+    status: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type TwilioCreateCallOutput = z.infer<typeof twilioCreateCallOutput>;
+export declare const twilioIncomingNumber: z.ZodObject<{
+    sid: z.ZodString;
+    phoneNumber: z.ZodString;
+    friendlyName: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>;
+export type TwilioIncomingNumber = z.infer<typeof twilioIncomingNumber>;
+export declare const twilioListIncomingNumbersOutput: z.ZodArray<z.ZodObject<{
+    sid: z.ZodString;
+    phoneNumber: z.ZodString;
+    friendlyName: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>>;
+export type TwilioListIncomingNumbersOutput = z.infer<typeof twilioListIncomingNumbersOutput>;
+export type TwilioService = {
+    sendSms(input: TwilioSendSmsInput): Promise<TwilioSendSmsOutput>;
+    createCall(input: TwilioCreateCallInput): Promise<TwilioCreateCallOutput>;
+    listIncomingNumbers(): Promise<TwilioListIncomingNumbersOutput>;
+};
+/** Stand-in surface for fake contexts and local runs; never reaches Twilio. */
+export declare const twilioMockService: TwilioService;
+export type TwilioApi = IntegrationAccountFields & TwilioService;
+//# sourceMappingURL=twilio.d.ts.map

package/dist/core/context/twilio.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export const twilioSendSmsInput = z.object({
+    to: z.string(),
+    body: z.string(),
+    from: z.string().optional(),
+});
+export const twilioSendSmsOutput = z.object({
+    ok: z.literal(true),
+    sid: z.string(),
+    status: z.string().nullable(),
+});
+export const twilioCreateCallInput = z.object({
+    to: z.string(),
+    from: z.string(),
+    url: z.string().optional(),
+    twiml: z.string().optional(),
+});
+export const twilioCreateCallOutput = z.object({
+    ok: z.literal(true),
+    sid: z.string(),
+    status: z.string().nullable(),
+});
+export const twilioIncomingNumber = z.object({
+    sid: z.string(),
+    phoneNumber: z.string(),
+    friendlyName: z.string(),
+    status: z.string(),
+});
+export const twilioListIncomingNumbersOutput = z.array(twilioIncomingNumber);
+/** Stand-in surface for fake contexts and local runs; never reaches Twilio. */
+export const twilioMockService = {
+    async sendSms() {
+        return { ok: true, sid: 'SM-mock', status: 'queued' };
+    },
+    async createCall() {
+        return { ok: true, sid: 'CA-mock', status: 'queued' };
+    },
+    async listIncomingNumbers() {
+        return [];
+    },
+};
+//# sourceMappingURL=twilio.js.map