@brokr/sdk 1.0.0 → 2.0.0

package/dist/src/email/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Brokr SDK — Email types
+ */
+export interface EmailParams {
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    /**
+     * Override the from address. Must be on your stack's verified domain.
+     * Defaults to noreply@{your stack domain}.
+     */
+    from?: string;
+}
+/** Built-in template names. */
+export type BuiltinTemplateName = 'welcome' | 'magicLink' | 'passwordReset' | 'invoice' | 'notification';
+export interface SendTemplateParams {
+    /** Template name — must be a built-in template or a custom one you've registered. */
+    template: BuiltinTemplateName | (string & {});
+    /** Recipient email(s). */
+    to: string | string[];
+    /** Variables to interpolate into the template. */
+    variables: Record<string, string>;
+    /** Override the from address. */
+    from?: string;
+}
+export interface EmailTemplate {
+    /** Template identifier. */
+    name: string;
+    /** Subject line pattern with {{variable}} placeholders. */
+    subject: string;
+    /** HTML render function. */
+    html: (variables: Record<string, string>) => string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/email/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/email/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,+BAA+B;AAC/B,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,WAAW,GAAG,eAAe,GAAG,SAAS,GAAG,cAAc,CAAC;AAEzG,MAAM,WAAW,kBAAkB;IACjC,qFAAqF;IACrF,QAAQ,EAAE,mBAAmB,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAC9C,0BAA0B;IAC1B,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACtB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;CACrD"}

package/dist/src/env-detect.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Brokr Environment Detection — zero-config, zero-setup.
+ *
+ * Determines dev/staging/production automatically from deployment signals.
+ * Developers never set this. It just works.
+ *
+ * Detection logic:
+ *   - No VERCEL env var → dev (local machine, `next dev`, `node server.js`)
+ *   - VERCEL + VERCEL_ENV=preview → staging (preview deployments, `brokr create --staging`)
+ *   - VERCEL + VERCEL_ENV=production → production (live deployment)
+ *   - Fallback: localhost hostname → dev, *.brokr.sh → production
+ */
+export type BrokrEnv = 'development' | 'staging' | 'production';
+/**
+ * Detect the current Brokr environment. Result is cached after first call.
+ * Works server-side (Node.js) and client-side (browser).
+ */
+export declare function detectEnv(): BrokrEnv;
+/** Check if we're in a development environment. */
+export declare function isDev(): boolean;
+/** Check if we're in a staging/preview environment. */
+export declare function isStaging(): boolean;
+/** Check if we're in production. */
+export declare function isProd(): boolean;
+//# sourceMappingURL=env-detect.d.ts.map

package/dist/src/env-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-detect.d.ts","sourceRoot":"","sources":["../../src/env-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,QAAQ,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;AAIhE;;;GAGG;AACH,wBAAgB,SAAS,IAAI,QAAQ,CAIpC;AAED,mDAAmD;AACnD,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED,uDAAuD;AACvD,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED,oCAAoC;AACpC,wBAAgB,MAAM,IAAI,OAAO,CAEhC"}

package/dist/src/errors.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Brokr SDK — Error hierarchy
+ *
+ * All SDK errors extend BrokrError with structured codes, capability tags,
+ * and retryable hints so callers can programmatically handle failures.
+ *
+ * New in v2: errorCode, requestId, hint, component stamping, fix/docsUrl getters.
+ */
+export declare class BrokrError extends Error {
+    readonly code: string;
+    readonly capability?: string | undefined;
+    readonly retryable: boolean;
+    readonly errorCode?: string | undefined;
+    readonly requestId?: string | undefined;
+    readonly hint?: string | undefined;
+    /** Stamped by each SDK client method for "which component broke" attribution. */
+    component?: string;
+    constructor(message: string, code: string, capability?: string | undefined, retryable?: boolean, errorCode?: string | undefined, requestId?: string | undefined, hint?: string | undefined);
+    /** Multi-line terminal fix block — looked up from error code. */
+    get fix(): string | undefined;
+    /** Documentation URL for this error code. */
+    get docsUrl(): string | undefined;
+    /** Safe message for end users — zero technical language. */
+    toUserMessage(): string;
+    toString(): string;
+    toJSON(): object;
+}
+/** Thrown when BROKR_TOKEN is missing or invalid. */
+export declare class BrokrAuthError extends BrokrError {
+    constructor(message: string, code: string);
+}
+/** Thrown on HTTP 429 — includes `retryAfter` seconds from the Retry-After header. */
+export declare class BrokrRateLimitError extends BrokrError {
+    readonly retryAfter: number;
+    constructor(message: string, retryAfter: number, capability?: string);
+}
+/** Thrown when the Brokr gateway is unreachable. */
+export declare class BrokrNetworkError extends BrokrError {
+    constructor(message: string, capability?: string);
+}
+/** Thrown when the request times out. */
+export declare class BrokrTimeoutError extends BrokrError {
+    constructor(message: string, capability?: string);
+}
+/** Thrown when a requested resource does not exist (HTTP 404). */
+export declare class BrokrNotFoundError extends BrokrError {
+    constructor(message: string, capability?: string);
+}
+/** Thrown when input validation fails. */
+export declare class BrokrValidationError extends BrokrError {
+    constructor(message: string, capability?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,qBAAa,UAAW,SAAQ,KAAK;aAMjB,IAAI,EAAE,MAAM;aACZ,UAAU,CAAC,EAAE,MAAM;aACnB,SAAS;aACT,SAAS,CAAC,EAAE,MAAM;aAClB,SAAS,CAAC,EAAE,MAAM;aAClB,IAAI,CAAC,EAAE,MAAM;IAV/B,iFAAiF;IACjF,SAAS,CAAC,EAAE,MAAM,CAAC;gBAGjB,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,SAAS,UAAQ,EACjB,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,IAAI,CAAC,EAAE,MAAM,YAAA;IAM/B,iEAAiE;IACjE,IAAI,GAAG,IAAI,MAAM,GAAG,SAAS,CAG5B;IAED,6CAA6C;IAC7C,IAAI,OAAO,IAAI,MAAM,GAAG,SAAS,CAGhC;IAED,4DAA4D;IAC5D,aAAa,IAAI,MAAM;IAuBvB,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,MAAM;CAajB;AAED,qDAAqD;AACrD,qBAAa,cAAe,SAAQ,UAAU;gBAChC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAI1C;AAED,sFAAsF;AACtF,qBAAa,mBAAoB,SAAQ,UAAU;aAG/B,UAAU,EAAE,MAAM;gBADlC,OAAO,EAAE,MAAM,EACC,UAAU,EAAE,MAAM,EAClC,UAAU,CAAC,EAAE,MAAM;CAKtB;AAED,oDAAoD;AACpD,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAIjD;AAED,yCAAyC;AACzC,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAIjD;AAED,kEAAkE;AAClE,qBAAa,kBAAmB,SAAQ,UAAU;gBACpC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAIjD;AAED,0CAA0C;AAC1C,qBAAa,oBAAqB,SAAQ,UAAU;gBACtC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAIjD"}

package/dist/src/events/client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Event Bus — Client
+ *
+ * v1: Local synchronous event dispatch within the same feature/request.
+ * v2 (future): Cross-feature events via gateway + CF Queues.
+ */
+import type { EmitResult } from './types';
+import type { EventHandler } from './types';
+/**
+ * Creates a scoped event bus for a single feature.
+ * Handlers registered with on() fire synchronously when emit() is called.
+ */
+export declare function createEventBus(featureSlug: string): {
+    /**
+     * Register a handler for an event.
+     * In v1, handlers fire synchronously within the same request.
+     */
+    on<T = unknown>(event: string, handler: EventHandler<T>): void;
+    /**
+     * Emit an event. In v1, dispatches synchronously to all registered handlers.
+     * Returns a deliveryId for idempotency tracking.
+     */
+    emit<T = unknown>(event: string, payload: T): Promise<EmitResult>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/src/events/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/events/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,SAAS,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM;IAI9C;;;OAGG;OACA,CAAC,mBAAmB,MAAM,WAAW,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;IAO9D;;;OAGG;SACQ,CAAC,mBAAmB,MAAM,WAAW,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;EAoB1E"}

package/dist/src/events/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Event Bus — Public API
+ *
+ * Re-exports the event bus factory and types for @brokr/sdk/events.
+ */
+export { createEventBus } from './client';
+export type { FeatureEvent, EmitResult } from './types';
+export type { EventHandler } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/events/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACxD,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/src/events/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Event Bus — Types
+ *
+ * Re-exports core event types from feature/types.ts.
+ * Separate file for the ./events export path.
+ */
+export type { EmitResult, FeatureEvent } from '../feature/types';
+/** Event handler function signature. */
+export type EventHandler<T = unknown> = (event: import('../feature/types').FeatureEvent<T>) => Promise<void>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/events/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/events/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEjE,wCAAwC;AACxC,MAAM,MAAM,YAAY,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,kBAAkB,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/src/feature/canonical.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creator SDK — Canonical Entity Resolution
+ *
+ * Provides brokr.user(id) and brokr.users(ids) for feature creators.
+ * Resolves users from the vibe coder's own user table using convention-based
+ * or explicit mapping from brokr.config.ts.
+ *
+ * Uses request-scoped batching to prevent N+1 queries — multiple
+ * brokr.user(id) calls in the same microtask batch into a single SQL query.
+ */
+import type { CanonicalUser } from './types';
+/** Known table names that typically hold user data. */
+export declare const USER_TABLE_CONVENTIONS: string[];
+/** Known column names by canonical field. */
+export declare const COLUMN_CONVENTIONS: Record<string, string[]>;
+/**
+ * Scan information_schema.columns and auto-detect user table mapping.
+ * Used by the install flow — NOT at runtime.
+ */
+export declare function detectUserMapping(sql: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<Record<string, unknown>[]>): Promise<{
+    table: string;
+    columns: Record<string, string>;
+} | null>;
+/**
+ * Creates a user resolver with request-scoped batching.
+ * Multiple calls to resolveUser() in the same microtask get batched
+ * into a single SQL query.
+ */
+export declare function createUserResolver(): {
+    resolveUser: (id: string) => Promise<CanonicalUser | null>;
+    resolveUsers: (ids: string[]) => Promise<Map<string, CanonicalUser>>;
+};
+//# sourceMappingURL=canonical.d.ts.map

package/dist/src/feature/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../../../src/feature/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAO7C,uDAAuD;AACvD,eAAO,MAAM,sBAAsB,UAAuD,CAAC;AAE3F,6CAA6C;AAC7C,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAKvD,CAAC;AAEF;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAC/F,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,CA0BpE;AAMD;;;;GAIG;AACH,wBAAgB,kBAAkB;sBAwEP,MAAM,KAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;wBAa9B,MAAM,EAAE,KAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;EAWhF"}

package/dist/src/feature/create-feature.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creator SDK — createBrokrFeature
+ *
+ * The main entry point for feature creators. Provides a scoped FeatureRuntime
+ * with isolated database, canonical entity resolution, events, and all existing
+ * Brokr capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { createBrokrFeature } from '@brokr/sdk/feature'
+ *
+ * export const { LikeButton, handlers } = createBrokrFeature('tinder-likes', (brokr) => ({
+ *   LikeButton: () => <button onClick={() => like()}>Like</button>,
+ *   handlers: brokr.handlers({
+ *     like: async (req) => {
+ *       const { toUserId } = await req.json()
+ *       await brokr.db.sql`INSERT INTO likes (from_user_id, to_user_id) VALUES (${userId}, ${toUserId})`
+ *       return { ok: true }
+ *     },
+ *   }),
+ * }))
+ * ```
+ */
+import { type FeatureRuntime } from './runtime';
+/**
+ * Create a Brokr feature with a scoped runtime.
+ *
+ * @param slug - Feature slug (e.g., 'tinder-likes'). Must match the slug in feature.json.
+ * @param factory - Function that receives the scoped FeatureRuntime and returns named exports.
+ * @returns The plain object of named exports (components, hooks, handlers) from the factory.
+ */
+export declare function createBrokrFeature<T extends Record<string, unknown>>(slug: string, factory: (brokr: FeatureRuntime) => T): T;
+//# sourceMappingURL=create-feature.d.ts.map

package/dist/src/feature/create-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-feature.d.ts","sourceRoot":"","sources":["../../../src/feature/create-feature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAErE;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,CAAC,GACpC,CAAC,CAWH"}

package/dist/src/feature/db.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creator SDK — Scoped Database Client
+ *
+ * Provides brokr.db.sql and brokr.db.query for feature creators.
+ * All queries execute against the feature's isolated Postgres schema.
+ *
+ * The SDK reads DATABASE_URL from env (injected by Brokr at provision time)
+ * and sets search_path = brokr_{slug}, public on the connection.
+ */
+import type { FeatureDb } from './types';
+/**
+ * Creates a scoped database client for a feature.
+ * Sets search_path to the feature's schema so all queries are isolated.
+ */
+export declare function createFeatureDb(schemaName: string): FeatureDb;
+//# sourceMappingURL=db.d.ts.map

package/dist/src/feature/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../../src/feature/db.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAoB,MAAM,SAAS,CAAC;AAmB3D;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAyD7D"}

package/dist/src/feature/handlers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Creator SDK — HTTP Handler Factory
+ *
+ * Creates GET/POST route handlers for feature API routes.
+ * Generalizes the createBrokrHandlers pattern from chat.ts.
+ *
+ * Usage by creator:
+ *   handlers: brokr.handlers({
+ *     like: async (req) => { ... return { ok: true } },
+ *     unlike: async (req) => { ... return { ok: true } },
+ *   })
+ *
+ * Wired by vibe coder:
+ *   // app/api/brokr/tinder-likes/route.ts
+ *   import { handlers } from '@/features/tinder-likes/server'
+ *   export const { GET, POST } = handlers
+ *
+ * Routes dispatched via ?action=<name>:
+ *   POST /api/brokr/tinder-likes?action=like
+ *   GET  /api/brokr/tinder-likes?action=list
+ */
+import type { HandlerFn, FeatureHandlers } from './types';
+/**
+ * Creates feature HTTP handlers from a route map.
+ * Each handler receives the raw Request and returns a Response or plain object.
+ */
+export declare function createFeatureHandlers(featureSlug: string, routes: Record<string, HandlerFn>): FeatureHandlers;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/src/feature/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../src/feature/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1D;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAChC,eAAe,CAkDjB"}

package/dist/src/feature/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @brokr/sdk/feature — Creator SDK Entry Point
+ *
+ * The public API for feature creators building on the Brokr platform.
+ *
+ * @example
+ * ```typescript
+ * import { createBrokrFeature } from '@brokr/sdk/feature'
+ *
+ * export const { MyComponent, handlers } = createBrokrFeature('my-feature', (brokr) => ({
+ *   MyComponent: () => <div>Hello</div>,
+ *   handlers: brokr.handlers({ action: async (req) => ({ ok: true }) }),
+ * }))
+ * ```
+ */
+export { createBrokrFeature } from './create-feature';
+export { featureManifestSchema, parseFeatureManifest } from './manifest';
+export type { FeatureRuntime } from './runtime';
+export type { FeatureManifest } from './manifest';
+export type { CanonicalUser, EmitResult, FeatureEvent, NotifyParams, FeatureDb, FeatureHandlers, HandlerFn, UserMapping, FeatureContext, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/feature/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/feature/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACzE,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,YAAY,EACV,aAAa,EACb,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,eAAe,EACf,SAAS,EACT,WAAW,EACX,cAAc,GACf,MAAM,SAAS,CAAC"}

package/dist/src/feature/manifest.d.ts

@@ -0,0 +1,173 @@
+import { z } from 'zod';
+export declare const featureManifestSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodString;
+    requires: z.ZodDefault<z.ZodObject<{
+        capabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<["database", "deployment", "email", "repo", "ai_provider", "kv_store", "storage", "auth", "payments", "notifications"]>, "many">>;
+        features: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        envVars: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        capabilities: ("notifications" | "auth" | "database" | "deployment" | "email" | "repo" | "ai_provider" | "kv_store" | "storage" | "payments")[];
+        features: string[];
+        envVars: Record<string, unknown>;
+    }, {
+        capabilities?: ("notifications" | "auth" | "database" | "deployment" | "email" | "repo" | "ai_provider" | "kv_store" | "storage" | "payments")[] | undefined;
+        features?: string[] | undefined;
+        envVars?: Record<string, unknown> | undefined;
+    }>>;
+    schema: z.ZodObject<{
+        namespace: z.ZodString;
+        migrations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            version: z.ZodString;
+            file: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            file: string;
+        }, {
+            version: string;
+            file: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        namespace: string;
+        migrations: {
+            version: string;
+            file: string;
+        }[];
+    }, {
+        namespace: string;
+        migrations?: {
+            version: string;
+            file: string;
+        }[] | undefined;
+    }>;
+    scaffold: z.ZodDefault<z.ZodObject<{
+        creates: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        devDependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        creates: string[];
+        dependencies: string[];
+        devDependencies: string[];
+    }, {
+        creates?: string[] | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+    }>>;
+    insertion: z.ZodOptional<z.ZodObject<{
+        targets: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        targets: Record<string, unknown>[];
+    }, {
+        targets?: Record<string, unknown>[] | undefined;
+    }>>;
+    events: z.ZodOptional<z.ZodObject<{
+        emits: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        listens: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        emits: string[];
+        listens: string[];
+    }, {
+        emits?: string[] | undefined;
+        listens?: string[] | undefined;
+    }>>;
+    expose: z.ZodOptional<z.ZodObject<{
+        components: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        handlers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        components: string[];
+        handlers: string[];
+    }, {
+        components?: string[] | undefined;
+        handlers?: string[] | undefined;
+    }>>;
+    dataContracts: z.ZodOptional<z.ZodObject<{
+        requires: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        requires?: Record<string, string[]> | undefined;
+    }, {
+        requires?: Record<string, string[]> | undefined;
+    }>>;
+    validates: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    requires: {
+        capabilities: ("notifications" | "auth" | "database" | "deployment" | "email" | "repo" | "ai_provider" | "kv_store" | "storage" | "payments")[];
+        features: string[];
+        envVars: Record<string, unknown>;
+    };
+    schema: {
+        namespace: string;
+        migrations: {
+            version: string;
+            file: string;
+        }[];
+    };
+    scaffold: {
+        creates: string[];
+        dependencies: string[];
+        devDependencies: string[];
+    };
+    validates: string[];
+    $schema?: string | undefined;
+    insertion?: {
+        targets: Record<string, unknown>[];
+    } | undefined;
+    events?: {
+        emits: string[];
+        listens: string[];
+    } | undefined;
+    expose?: {
+        components: string[];
+        handlers: string[];
+    } | undefined;
+    dataContracts?: {
+        requires?: Record<string, string[]> | undefined;
+    } | undefined;
+}, {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    schema: {
+        namespace: string;
+        migrations?: {
+            version: string;
+            file: string;
+        }[] | undefined;
+    };
+    $schema?: string | undefined;
+    requires?: {
+        capabilities?: ("notifications" | "auth" | "database" | "deployment" | "email" | "repo" | "ai_provider" | "kv_store" | "storage" | "payments")[] | undefined;
+        features?: string[] | undefined;
+        envVars?: Record<string, unknown> | undefined;
+    } | undefined;
+    scaffold?: {
+        creates?: string[] | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+    } | undefined;
+    insertion?: {
+        targets?: Record<string, unknown>[] | undefined;
+    } | undefined;
+    events?: {
+        emits?: string[] | undefined;
+        listens?: string[] | undefined;
+    } | undefined;
+    expose?: {
+        components?: string[] | undefined;
+        handlers?: string[] | undefined;
+    } | undefined;
+    dataContracts?: {
+        requires?: Record<string, string[]> | undefined;
+    } | undefined;
+    validates?: string[] | undefined;
+}>;
+export type FeatureManifest = z.infer<typeof featureManifestSchema>;
+export declare function parseFeatureManifest(input: unknown): FeatureManifest;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/src/feature/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/feature/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmCxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCvB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAEpE"}

package/dist/src/feature/mapping.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Creator SDK — Field Mapping Loader
+ *
+ * Loads the user mapping from brokr.config.ts (auto-generated at install time).
+ * Falls back to sensible defaults if the config file doesn't exist.
+ */
+import type { UserMapping } from './types';
+/**
+ * Load the user mapping from brokr.config.ts.
+ * Cached after first load — zero overhead on subsequent calls.
+ *
+ * Falls back to default mapping if brokr.config.ts doesn't exist or
+ * doesn't export a user mapping.
+ */
+export declare function loadUserMapping(): UserMapping;
+/** Reset the cached mapping (useful for testing). */
+export declare function resetMappingCache(): void;
+//# sourceMappingURL=mapping.d.ts.map

package/dist/src/feature/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/feature/mapping.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAa3C;;;;;;GAMG;AACH,wBAAgB,eAAe,IAAI,WAAW,CA0B7C;AAED,qDAAqD;AACrD,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}

package/dist/src/feature/runtime.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Creator SDK — Feature Runtime
+ *
+ * The FeatureRuntime is the scoped `brokr` object passed to createBrokrFeature factories.
+ * It provides isolated database access, canonical entity resolution, events, notifications,
+ * and all existing Brokr capabilities (AI, storage, email).
+ */
+import type { CanonicalUser, FeatureContext, EmitResult, NotifyParams, FeatureDb, FeatureHandlers, HandlerFn } from './types';
+import type { EventHandler } from '../events/types';
+import { BrokrAIClient } from '../ai/client';
+import { BrokrStorageClient } from '../storage/client';
+import { BrokrEmailClient } from '../email/client';
+import { BrokrPaymentsClient } from '../payments/client';
+export interface FeatureRuntime {
+    /** Scoped DB client — queries execute against brokr_{slug} schema. */
+    readonly db: FeatureDb;
+    /** Resolve a canonical user from the vibe coder's user table. */
+    user: (id: string) => Promise<CanonicalUser | null>;
+    /** Batch resolve canonical users. */
+    users: (ids: string[]) => Promise<Map<string, CanonicalUser>>;
+    /** Emit an event (v1: local sync, v2: CF Queue). */
+    emit: <T = unknown>(event: string, payload: T) => Promise<EmitResult>;
+    /** Listen for events. */
+    on: <T = unknown>(event: string, handler: EventHandler<T>) => void;
+    /** Send a notification via gateway. */
+    notify: (userId: string, params: NotifyParams) => Promise<void>;
+    /** Existing Brokr AI client. */
+    readonly ai: BrokrAIClient;
+    /** Existing Brokr storage client. */
+    readonly storage: BrokrStorageClient;
+    /** Existing Brokr email client. */
+    readonly email: BrokrEmailClient;
+    /** Existing Brokr payments client. */
+    readonly payments: BrokrPaymentsClient;
+    /** Create HTTP handlers for feature API routes. */
+    handlers: (routes: Record<string, HandlerFn>) => FeatureHandlers;
+    /** Current context from BrokrProvider session. */
+    readonly context: FeatureContext;
+}
+/**
+ * Build a FeatureRuntime for a given feature slug.
+ * Called internally by createBrokrFeature — not exported to creators.
+ */
+export declare function buildFeatureRuntime(slug: string): FeatureRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/src/feature/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/feature/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,UAAU,EACV,YAAY,EACZ,SAAS,EACT,eAAe,EACf,SAAS,EACV,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAKpD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AASzD,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC;IAEvB,iEAAiE;IACjE,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IACpD,qCAAqC;IACrC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IAE9D,oDAAoD;IACpD,IAAI,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACtE,yBAAyB;IACzB,EAAE,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAEnE,uCAAuC;IACvC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhE,gCAAgC;IAChC,QAAQ,CAAC,EAAE,EAAE,aAAa,CAAC;IAC3B,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IAEvC,mDAAmD;IACnD,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,KAAK,eAAe,CAAC;IAEjE,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAoGhE"}