@superpanel-sdk/runtime 0.2.2 → 0.5.0

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

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+export declare const SMS_PAGE_LIMIT_MAX = 100;
+export declare const smsDirection: z.ZodEnum<{
+    inbound: "inbound";
+    outbound: "outbound";
+}>;
+export type SmsDirection = z.infer<typeof smsDirection>;
+/**
+ * Script-facing SMS projection (21 §5.10). A text line is our number and theirs: `from` / `to` are the
+ * message's own. Provider metadata stays private.
+ */
+export declare const smsRecord: z.ZodObject<{
+    id: z.ZodString;
+    instanceId: z.ZodNullable<z.ZodString>;
+    contactId: z.ZodNullable<z.ZodString>;
+    runId: z.ZodNullable<z.ZodString>;
+    direction: z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>;
+    from: z.ZodString;
+    to: z.ZodString;
+    body: z.ZodNullable<z.ZodString>;
+    processing: z.ZodNullable<z.ZodString>;
+    delivery: z.ZodNullable<z.ZodString>;
+    errorCode: z.ZodNullable<z.ZodString>;
+    occurredAt: z.ZodString;
+}, z.core.$strip>;
+export type SmsRecord = z.infer<typeof smsRecord>;
+export declare const smsListInput: z.ZodObject<{
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+    instanceId: z.ZodOptional<z.ZodString>;
+    contactId: z.ZodOptional<z.ZodString>;
+    counterpart: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>>;
+}, z.core.$strip>;
+export type SmsListParams = z.infer<typeof smsListInput>;
+export declare const smsListOutput: z.ZodObject<{
+    sms: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        instanceId: z.ZodNullable<z.ZodString>;
+        contactId: z.ZodNullable<z.ZodString>;
+        runId: z.ZodNullable<z.ZodString>;
+        direction: z.ZodEnum<{
+            inbound: "inbound";
+            outbound: "outbound";
+        }>;
+        from: z.ZodString;
+        to: z.ZodString;
+        body: z.ZodNullable<z.ZodString>;
+        processing: z.ZodNullable<z.ZodString>;
+        delivery: z.ZodNullable<z.ZodString>;
+        errorCode: z.ZodNullable<z.ZodString>;
+        occurredAt: z.ZodString;
+    }, z.core.$strip>>;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export type SmsListResult = z.infer<typeof smsListOutput>;
+export declare const smsGetInput: z.ZodString;
+export declare const smsGetOutput: z.ZodNullable<z.ZodObject<{
+    id: z.ZodString;
+    instanceId: z.ZodNullable<z.ZodString>;
+    contactId: z.ZodNullable<z.ZodString>;
+    runId: z.ZodNullable<z.ZodString>;
+    direction: z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>;
+    from: z.ZodString;
+    to: z.ZodString;
+    body: z.ZodNullable<z.ZodString>;
+    processing: z.ZodNullable<z.ZodString>;
+    delivery: z.ZodNullable<z.ZodString>;
+    errorCode: z.ZodNullable<z.ZodString>;
+    occurredAt: z.ZodString;
+}, z.core.$strip>>;
+/** Platform SMS capability, reached from scripts as `ctx.api.sms`. */
+export type SmsApi = {
+    list(input: SmsListParams): Promise<SmsListResult>;
+    get(id: string): Promise<SmsRecord | null>;
+};
+export declare const smsMockService: SmsApi;
+export declare const smsSurface: {
+    methods: {
+        list: {
+            input: z.ZodObject<{
+                offset: z.ZodNumber;
+                limit: z.ZodNumber;
+                instanceId: z.ZodOptional<z.ZodString>;
+                contactId: z.ZodOptional<z.ZodString>;
+                counterpart: z.ZodOptional<z.ZodString>;
+                direction: z.ZodOptional<z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>>;
+            }, z.core.$strip>;
+            output: z.ZodObject<{
+                sms: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    instanceId: z.ZodNullable<z.ZodString>;
+                    contactId: z.ZodNullable<z.ZodString>;
+                    runId: z.ZodNullable<z.ZodString>;
+                    direction: z.ZodEnum<{
+                        inbound: "inbound";
+                        outbound: "outbound";
+                    }>;
+                    from: z.ZodString;
+                    to: z.ZodString;
+                    body: z.ZodNullable<z.ZodString>;
+                    processing: z.ZodNullable<z.ZodString>;
+                    delivery: z.ZodNullable<z.ZodString>;
+                    errorCode: z.ZodNullable<z.ZodString>;
+                    occurredAt: z.ZodString;
+                }, z.core.$strip>>;
+                offset: z.ZodNumber;
+                limit: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+        get: {
+            input: z.ZodString;
+            output: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                instanceId: z.ZodNullable<z.ZodString>;
+                contactId: z.ZodNullable<z.ZodString>;
+                runId: z.ZodNullable<z.ZodString>;
+                direction: z.ZodEnum<{
+                    inbound: "inbound";
+                    outbound: "outbound";
+                }>;
+                from: z.ZodString;
+                to: z.ZodString;
+                body: z.ZodNullable<z.ZodString>;
+                processing: z.ZodNullable<z.ZodString>;
+                delivery: z.ZodNullable<z.ZodString>;
+                errorCode: z.ZodNullable<z.ZodString>;
+                occurredAt: z.ZodString;
+            }, z.core.$strip>>;
+        };
+    };
+    mock: SmsApi;
+};
+//# sourceMappingURL=sms.d.ts.map

package/dist/core/context/sms.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export const SMS_PAGE_LIMIT_MAX = 100;
+export const smsDirection = z.enum(['inbound', 'outbound']);
+/**
+ * Script-facing SMS projection (21 §5.10). A text line is our number and theirs: `from` / `to` are the
+ * message's own. Provider metadata stays private.
+ */
+export const smsRecord = z.object({
+    id: z.string(),
+    instanceId: z.string().nullable(),
+    contactId: z.string().nullable(),
+    /** Inbound: the run that handled it; outbound: the run that sent it (null: the platform did). */
+    runId: z.string().nullable(),
+    direction: smsDirection,
+    from: z.string(),
+    to: z.string(),
+    body: z.string().nullable(),
+    /** Inbound: pending | claimed | processed | skipped | declined | failed. */
+    processing: z.string().nullable(),
+    /** Outbound: pending | submitting | the provider's status (queued, sent, delivered, undelivered, failed …). */
+    delivery: z.string().nullable(),
+    /** The provider's error code, as given. */
+    errorCode: z.string().nullable(),
+    occurredAt: z.string(),
+});
+export const smsListInput = z.object({
+    offset: z.number().int().min(0),
+    limit: z.number().int().min(1).max(SMS_PAGE_LIMIT_MAX),
+    instanceId: z.string().optional(),
+    contactId: z.string().optional(),
+    /** Their number: one text line with them (on any of our numbers). */
+    counterpart: z.string().optional(),
+    direction: smsDirection.optional(),
+});
+export const smsListOutput = z.object({
+    sms: z.array(smsRecord),
+    offset: z.number().int(),
+    limit: z.number().int(),
+});
+export const smsGetInput = z.string().min(1);
+export const smsGetOutput = smsRecord.nullable();
+export const smsMockService = {
+    async list(input) {
+        return { sms: [], offset: input.offset, limit: input.limit };
+    },
+    async get() {
+        return null;
+    },
+};
+export const smsSurface = {
+    methods: {
+        list: { input: smsListInput, output: smsListOutput },
+        get: { input: smsGetInput, output: smsGetOutput },
+    },
+    mock: smsMockService,
+};
+//# sourceMappingURL=sms.js.map

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

@@ -1,79 +1,100 @@
-import type { FieldPath } from '../slot/path.js';
 import type { PlatformApis } from './platform-registry.js';
-import type { DocusignApi } from './docusign.js';
+import type { Db } from '../page/define.js';
+import type { EmailApi } from './email.js';
 import type { EnvApi } from './env.js';
-import type { FilevineApi } from './filevine.js';
-import type { HubspotApi } from './hubspot.js';
-import type { TwilioApi } from './twilio.js';
-import type { HttpApi } from './http.js';
 import type { IntegrationAccountFields } from './account-fields.js';
 export type { IntegrationAccountFields, IntegrationTarget } from './account-fields.js';
-export type FieldState = 'empty' | 'filled' | 'asked_unknown' | 'declined';
-/**
- * Fallback Slots. Sequence `__gen/slots.type.ts` provides the narrowed shape;
- * `view.ts` selectors import that type.
- */
-export type Slots = Record<string, unknown>;
 /**
- * Fallback CaseContext (no view / before narrowing).
- * With `view.ts`, use `CaseContextOf<typeof caseContextView>` from that module.
+ * Lifecycle state of a slot field (`01-slot-design §2`):
+ * - `'empty'`: Not yet asked or set (`value` is `null`). Not `resolved`.
+ * - `'filled'`: Has an answer (`value` is non-null). Counts as `resolved`.
+ * - `'asked_unknown'`: Asked, and the contact does not know / cannot remember (`value` is `null` or a coarse value). Counts as `resolved`.
+ * - `'declined'`: Asked, and the contact refused to answer (`value` is `null`). Counts as `resolved`.
  */
-export type CaseContext = Record<string, unknown>;
-export type Writes = Record<FieldPath, unknown>;
+export type FieldState = 'empty' | 'filled' | 'asked_unknown' | 'declined';
+/** Field states a write can set without a value; the platform stores `value: null`. */
+export type SlotWriteClearState = 'empty' | 'asked_unknown' | 'declined';
 export type Logger = {
     info: (message: string, extra?: Record<string, unknown>) => void;
     warn: (message: string, extra?: Record<string, unknown>) => void;
     error: (message: string, extra?: Record<string, unknown>) => void;
 };
-export type { DocusignApi, DocusignService } from './docusign.js';
+export type { EmailApi, EmailAttachment, EmailGetAttachmentInput, EmailGetAttachmentOutput, EmailGetMessageInput, EmailGetMessageOutput, EmailListMessagesInput, EmailListMessagesOutput, EmailProvider, EmailSendEmailInput, EmailSendEmailOutput, EmailService, } from './email.js';
 export type { EnvApi, EnvService } from './env.js';
-export type { FilevineApi, FilevineService } from './filevine.js';
-export type { HubspotApi, HubspotService } from './hubspot.js';
-export type { TwilioApi, TwilioCreateCallInput, TwilioCreateCallOutput, TwilioIncomingNumber, TwilioListIncomingNumbersOutput, TwilioSendSmsInput, TwilioSendSmsOutput, TwilioService, } from './twilio.js';
 export type { ContactApi, ContactListParams, ContactListResult, ContactSummary } from './contact.js';
-export type { HttpApi } from './http.js';
 /**
  * Integration API: surfaceKey → array of bound stubs.
  * Add a key here when the platform adds a script surface; the provider table must implement it.
  */
 export type IntegrationApi = {
-    hubspots?: HubspotApi[];
-    twilios?: TwilioApi[];
-    filevines?: FilevineApi[];
-    docusigns?: DocusignApi[];
     envs?: EnvApi[];
+    emails?: EmailApi[];
 };
 export type IntegrationSurfaceKey = keyof IntegrationApi;
 type SurfaceItem<K extends IntegrationSurfaceKey> = NonNullable<IntegrationApi[K]>[number];
 export type IntegrationStub = SurfaceItem<IntegrationSurfaceKey>;
-export declare const integrationSurfaceKeys: readonly ["hubspots", "twilios", "filevines", "docusigns", "envs"];
-export type BoundIntegrationMeta = IntegrationAccountFields & {
+export declare const integrationSurfaceKeys: readonly ["envs", "emails"];
+export type IntegrationSurfaceMeta = IntegrationAccountFields & {
     surfaceKey: IntegrationSurfaceKey;
     methods: string[];
 };
 /** Context injected into custom and system functions. */
 export type SystemContext = {
     time: Readonly<{
+        /** Current wall-clock timestamp in epoch milliseconds (use instead of `Date.now()`). */
         now: number;
+        /** IANA timezone of `today`; currently always `'UTC'` (not the contact's or office's timezone). */
         timezone: string;
+        /** Current calendar date (`YYYY-MM-DD`) in `time.timezone`, i.e. the UTC date. */
         today: string;
+        /**
+         * `at` as people read it, in `timeZone` (25 §11): "Tue, Nov 3, 3:00 PM EST" (`style` `'date'` or
+         * `'time'` for one part). A contact's zone is `contactTimezone(…)`.
+         */
+        format(at: string | number, options: {
+            timeZone: string;
+            style?: 'datetime' | 'date' | 'time';
+        }): string;
+        /** The calendar day (`YYYY-MM-DD`) at `at` in `timeZone` (25 §11), to compare days or key a rule by date. */
+        day(at: string | number, timeZone: string): string;
     }>;
     meta: Readonly<{
         companyId: string;
         environmentId: string;
         sequenceId: string;
+        /**
+         * What the function runs under: `'voice'` / `'sms'` / `'email'` in a conversation,
+         * `'orchestrator'` in an Orchestrator Run, `'resolve'` when resolving a conversation.
+         */
         entry: string;
-        contactId: string;
-        caseId: string;
+        /**
+         * The instance the function runs on; null when none (`resolve`, a webhook, a handler without one).
+         * Who the conversation is with, and its session, are not here (28 §4): a page passes them as the
+         * function's params (`runFunction(name, { prefill: { contactId: ctx.caller.id, sessionId: ctx.session.id } })`).
+         */
+        instanceId: string | null;
+        /**
+         * A function pressed as a button (25 §11): this press's key, the same when the AI presses it again with
+         * the same arguments in the same run. Send it to another system as its idempotency key, so a second
+         * press does not do the work twice. Absent outside a button.
+         */
+        idempotencyKey?: string;
     }>;
     config: Readonly<{
+        /** Base URL of the frontend app. */
         frontendUrl: string;
+        /** Base URL of the backend RPC endpoint. */
         backendUrl: string;
     }>;
     api: PlatformApis & {
         integration: IntegrationApi;
         log: Logger;
-        http: HttpApi;
+        /**
+         * The company's records, Prisma-shaped (`db.<table>.findMany(…)`, `db.<table>.update(…)`): reads
+         * like a page script's (every `where` anchored), writes like a page action's, through the explicit
+         * write entry, each call its own transaction. Any row of the company and environment.
+         */
+        db: Db;
     };
 };
 export type MakeCtxOverrides = {

package/dist/core/context/types.js

@@ -1,9 +1,3 @@
-export const integrationSurfaceKeys = [
-    'hubspots',
-    'twilios',
-    'filevines',
-    'docusigns',
-    'envs',
-];
+export const integrationSurfaceKeys = ['envs', 'emails'];
 true;
 //# sourceMappingURL=types.js.map

package/dist/core/conversation/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * What the platform knows of a conversation's channel, shared by the page, the engine and the pipeline.
+ */
+export type Direction = 'inbound' | 'outbound';
+/** The channels a conversation runs on. A conversation engine runs on calls and SMS (17b §9.0); email routes and stores only. */
+export declare const CHANNELS: readonly ['call', 'sms', 'email'];
+export type Channel = (typeof CHANNELS)[number];
+/**
+ * The languages the platform speaks: the values of the contact's `language` field. Each needs a voice
+ * (the default voice profile's settings for it) and the platform's fixed lines in it.
+ */
+export declare const SPOKEN_LANGUAGES: readonly ['english', 'spanish'];
+/** A spoken language as the contact's `language` field holds it (`english`, `spanish`). */
+export type SpokenLanguage = string;
+export declare function isSpokenLanguage(value: unknown): value is SpokenLanguage;
+/**
+ * The scheduled action that started an outbound conversation (a scheduled call or message), fixed for
+ * the session. An agreed follow-up has `agreedInExchangeId`; `note` says why it happens
+ * (docs/design/09-agreed-follow-up.md).
+ */
+export type ScheduledContactContext = {
+    scheduledActionId: string;
+    /** Set for an agreed follow-up: the exchange the party asked for or agreed to it in. */
+    agreedInExchangeId: string | null;
+    /** An agreed follow-up: the party's own words agreeing to it; null otherwise. */
+    customerQuote: string | null;
+    note: string | null;
+    /** When it was due, ISO 8601. */
+    scheduledFor: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/core/conversation/index.js

@@ -0,0 +1,14 @@
+/**
+ * What the platform knows of a conversation's channel, shared by the page, the engine and the pipeline.
+ */
+/** The channels a conversation runs on. A conversation engine runs on calls and SMS (17b §9.0); email routes and stores only. */
+export const CHANNELS = ['call', 'sms', 'email'];
+/**
+ * The languages the platform speaks: the values of the contact's `language` field. Each needs a voice
+ * (the default voice profile's settings for it) and the platform's fixed lines in it.
+ */
+export const SPOKEN_LANGUAGES = ['english', 'spanish'];
+export function isSpokenLanguage(value) {
+    return typeof value === 'string' && SPOKEN_LANGUAGES.includes(value.trim());
+}
+//# sourceMappingURL=index.js.map

package/dist/core/functions/define/bind.d.ts

@@ -0,0 +1,25 @@
+import type { CaseInput } from '../../case-orchestrator/types.js';
+import type { PageTablesDesc } from '../../page/typed.js';
+import type { EventHandlers } from '../events.js';
+import type { CaseFn, DefinedCaseFunc, DefinedNoCaseFunc, FuncOptions, NoCaseFn } from '../types.js';
+/**
+ * The define helpers bound to one sequence: functions' and event handlers' `c` to its case (`C`: the
+ * instance and its business root's id), `ctx.api.db` to its `PageTables` (`D`).
+ */
+export type BoundDefines<D extends PageTablesDesc | undefined = undefined, C = CaseInput> = {
+    defineCaseFunc: {
+        /** A function that writes with `ctx.api.db` and returns nothing. */
+        <P extends object = object>(main: CaseFn<C, P, void, D>, options?: FuncOptions): DefinedCaseFunc<C, P, void, D>;
+        /** Any other return type, spelled out: `defineCaseFunc<object, string>(…)` (`R` is never inferred). */
+        <P extends object = object, R = never>(main: CaseFn<C, P, NoInfer<R>, D>, options?: FuncOptions): DefinedCaseFunc<C, P, R, D>;
+    };
+    /** Nocase function: no `c`; reads and writes with `ctx.api.db`. */
+    defineNoCaseFunc: <P extends object = object, R = unknown>(main: NoCaseFn<P, R, D>, options?: FuncOptions) => DefinedNoCaseFunc<P, R, D>;
+    defineEvents: (handlers: EventHandlers<C, D>) => EventHandlers<C, D>;
+};
+/**
+ * Bind the define helpers to a sequence. `type:gen` emits `__gen/index.ts` calling this, so company
+ * code never spells the types: `defineCaseFunc(async (c, ctx) => …)`.
+ */
+export declare function bindDefines<D extends PageTablesDesc | undefined = undefined, C = CaseInput>(): BoundDefines<D, C>;
+//# sourceMappingURL=bind.d.ts.map

package/dist/core/functions/define/bind.js

@@ -0,0 +1,14 @@
+import { defineCaseFunc } from './case.js';
+import { defineNoCaseFunc } from './no-case.js';
+/**
+ * Bind the define helpers to a sequence. `type:gen` emits `__gen/index.ts` calling this, so company
+ * code never spells the types: `defineCaseFunc(async (c, ctx) => …)`.
+ */
+export function bindDefines() {
+    return {
+        defineCaseFunc: defineCaseFunc,
+        defineNoCaseFunc: defineNoCaseFunc,
+        defineEvents: (handlers) => handlers,
+    };
+}
+//# sourceMappingURL=bind.js.map

package/dist/core/functions/define/case.d.ts

@@ -0,0 +1,9 @@
+import type { CaseFn, DefinedCaseFunc, FuncOptions } from '../types.js';
+import type { CaseInput } from '../../case-orchestrator/types.js';
+/**
+ * Worker function bound to a case: `(c, ctx) => R`, `c` the instance and its business root's id.
+ * `R` defaults to `void` (a function that writes with `ctx.api.db`); other callers
+ * pass their own. Company code normally uses the bound version from `__gen/index.ts` so `S` is never spelled.
+ */
+export declare function defineCaseFunc<S = CaseInput, P extends object = object, R = void>(main: CaseFn<S, P, R>, options?: FuncOptions): DefinedCaseFunc<S, P, R>;
+//# sourceMappingURL=case.d.ts.map

package/dist/core/functions/define/case.js

@@ -0,0 +1,13 @@
+/**
+ * Worker function bound to a case: `(c, ctx) => R`, `c` the instance and its business root's id.
+ * `R` defaults to `void` (a function that writes with `ctx.api.db`); other callers
+ * pass their own. Company code normally uses the bound version from `__gen/index.ts` so `S` is never spelled.
+ */
+export function defineCaseFunc(main, options) {
+    return {
+        kind: 'case',
+        main,
+        ...options,
+    };
+}
+//# sourceMappingURL=case.js.map

package/dist/core/functions/define/events.d.ts

@@ -0,0 +1,20 @@
+import type { CaseInput } from '../../case-orchestrator/types.js';
+import type { PageTablesDesc } from '../../page/typed.js';
+import type { EventHandlers, WebhookHandler } from '../events.js';
+/**
+ * Author-side helper for the `events` export. The parameter type is fully known,
+ * so handler arguments are contextually typed and unknown event names are
+ * rejected as excess properties.
+ *
+ * ```ts
+ * export const events = defineEvents({
+ *   'call.ended': async (c, ctx) => {
+ *     await ctx.api.db.matter.update({ where: { id: c.subject }, data: { last_call: ctx.params.event.outcome } });
+ *   },
+ * });
+ * ```
+ */
+export declare function defineEvents<C = CaseInput, D extends PageTablesDesc | undefined = undefined>(handlers: EventHandlers<C, D>): EventHandlers<C, D>;
+/** Author-side helper for `webhook.ts`'s `received`: types `ctx.params.event` and the return. */
+export declare function defineWebhook<D extends PageTablesDesc | undefined = undefined>(handler: WebhookHandler<D>): WebhookHandler<D>;
+//# sourceMappingURL=events.d.ts.map

package/dist/core/functions/define/events.js

@@ -0,0 +1,21 @@
+/**
+ * Author-side helper for the `events` export. The parameter type is fully known,
+ * so handler arguments are contextually typed and unknown event names are
+ * rejected as excess properties.
+ *
+ * ```ts
+ * export const events = defineEvents({
+ *   'call.ended': async (c, ctx) => {
+ *     await ctx.api.db.matter.update({ where: { id: c.subject }, data: { last_call: ctx.params.event.outcome } });
+ *   },
+ * });
+ * ```
+ */
+export function defineEvents(handlers) {
+    return handlers;
+}
+/** Author-side helper for `webhook.ts`'s `received`: types `ctx.params.event` and the return. */
+export function defineWebhook(handler) {
+    return handler;
+}
+//# sourceMappingURL=events.js.map

package/dist/core/functions/define/no-case.d.ts

@@ -0,0 +1,4 @@
+import type { DefinedNoCaseFunc, FuncOptions, NoCaseFn } from '../types.js';
+/** Worker function not bound to a case: `(ctx) => R`. No case (`c`) is passed. */
+export declare function defineNoCaseFunc<P extends object = object, R = unknown>(main: NoCaseFn<P, R>, options?: FuncOptions): DefinedNoCaseFunc<P, R>;
+//# sourceMappingURL=no-case.d.ts.map

package/dist/core/functions/define/no-case.js

@@ -0,0 +1,9 @@
+/** Worker function not bound to a case: `(ctx) => R`. No case (`c`) is passed. */
+export function defineNoCaseFunc(main, options) {
+    return {
+        kind: 'noCase',
+        main,
+        ...options,
+    };
+}
+//# sourceMappingURL=no-case.js.map