@oddkin/ai 0.0.0-stage → 1.0.0-beta.0

package/dist/prompt-input/prompt-input.d.ts

@@ -0,0 +1,241 @@
+import { OddkinElement, type ElementEvents } from '@oddkin/core/element';
+import type { Scope } from '@oddkin/core/scope';
+import type { PublicError } from '../contracts/types.js';
+import { ComposerController, type ComposerIssue, type ComposerState } from '../controllers/composer.js';
+export declare const PROMPT_INPUT_STRINGS: {
+    label: string;
+    placeholder: string;
+    send: string;
+    stop: string;
+    attach: string;
+    remove: string;
+    hintSend: string;
+    hintNewline: string;
+    sending: string;
+    failed: string;
+    busyAttachments: string;
+    failedAttachments: string;
+    unavailable: string;
+    dropHere: string;
+    'ai.attachment.type': string;
+    'ai.attachment.size': string;
+    'ai.attachment.count': string;
+    'ai.attachment.unavailable': string;
+    selected: string;
+    uploading: string;
+    uploaded: string;
+    processing: string;
+    ready: string;
+    failedStatus: string;
+    removed: string;
+};
+declare const OddkinPromptInput_base: import("@oddkin/core/element").WithProps<typeof OddkinElement, {
+    readonly controller: import("@oddkin/core/element").PropDefinition<ComposerController | undefined>;
+    readonly label: import("@oddkin/core/element").PropDefinition<string>;
+    readonly placeholder: import("@oddkin/core/element").PropDefinition<string>;
+    readonly disabled: import("@oddkin/core/element").PropDefinition<boolean>;
+    readonly loading: import("@oddkin/core/element").PropDefinition<boolean>;
+    readonly attemptId: import("@oddkin/core/element").PropDefinition<string>;
+    readonly capabilities: import("@oddkin/core/element").PropDefinition<{
+        attachments?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        disconnect?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        edit?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        editApproval?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        feedback?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        history?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        reconnect?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        regenerate?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        respondToApproval?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        restoreCheckpoint?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        resume?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        retry?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        send?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        stop?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        switchBranch?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+        voice?: {
+            available: boolean;
+            reason?: string | undefined;
+        } | undefined;
+    } | undefined>;
+    readonly accept: import("@oddkin/core/element").PropDefinition<string>;
+    readonly maxFileSize: import("@oddkin/core/element").PropDefinition<number>;
+    readonly maxFiles: import("@oddkin/core/element").PropDefinition<number>;
+    readonly enterBehavior: import("@oddkin/core/element").PropDefinition<"newline" | "send">;
+    readonly strings: import("@oddkin/core/element").PropDefinition<Partial<{
+        label: string;
+        placeholder: string;
+        send: string;
+        stop: string;
+        attach: string;
+        remove: string;
+        hintSend: string;
+        hintNewline: string;
+        sending: string;
+        failed: string;
+        busyAttachments: string;
+        failedAttachments: string;
+        unavailable: string;
+        dropHere: string;
+        'ai.attachment.type': string;
+        'ai.attachment.size': string;
+        'ai.attachment.count': string;
+        'ai.attachment.unavailable': string;
+        selected: string;
+        uploading: string;
+        uploaded: string;
+        processing: string;
+        ready: string;
+        failedStatus: string;
+        removed: string;
+    }> | undefined>;
+}>;
+/**
+ * The prompt composer: an expanding text area with attachments (button, paste, and drop),
+ * toolbar slots, send and stop, and a draft that survives failures. Submission is a cancelable
+ * request; the host acknowledges or fails it by id, and acknowledging an older submission never
+ * clears newer edits. IME composition never submits.
+ *
+ * @slot header - Content above the input (suggestions, context).
+ * @slot toolbar-start - Controls before the attach button (model picker, commands).
+ * @slot toolbar-end - Controls before the send button (voice input).
+ * @csspart form - The native form.
+ * @csspart input - The native text area.
+ * @csspart attachments - Attachment list.
+ * @csspart toolbar - Toolbar row.
+ * @csspart status - Submission status and errors.
+ * @cssprop --odd-prompt-input-max-height - Maximum height before the text area scrolls.
+ * @a11y The text area is labelled (`label`) and described by the keyboard hint, validation issues, and submission status. Send and stop are native buttons; unavailable actions explain why.
+ * @keyboard Enter sends and Shift+Enter inserts a line break (or Ctrl/⌘+Enter sends with `enter-behavior="newline"`). Keys during IME composition never send.
+ * @useFor The input of a conversation or assistant.
+ * @notFor Single-line form fields; use `odd-input`.
+ * @limitation Mentions and slash commands are host integrations through the slots and the `input` part; the composer does not parse them.
+ * @customization 1 2
+ * @category AI
+ */
+export declare class OddkinPromptInput extends OddkinPromptInput_base {
+    #private;
+    static shadowRootOptions: ShadowRootInit;
+    static events: {
+        'odd-prompt-submit': import("@oddkin/core/element").EventDefinition<import("../events.js").PromptSubmitDetail>;
+        'odd-prompt-stop': import("@oddkin/core/element").EventDefinition<{
+            readonly attemptId: string | undefined;
+        }>;
+        'odd-attachment-add': import("@oddkin/core/element").EventDefinition<{
+            readonly attachments: readonly import("../controllers/composer.js").AttachmentState[];
+        }>;
+        'odd-attachment-remove': import("@oddkin/core/element").EventDefinition<{
+            readonly attachmentId: string;
+        }>;
+        'odd-announce': import("@oddkin/core/element").EventDefinition<import("../events.js").AnnounceDetail>;
+    };
+    readonly _events?: ElementEvents<typeof OddkinPromptInput>;
+    /** @internal Mirror of the composer state for the template. */
+    readonly _state: import("@oddkin/core/reactive").Signal<ComposerState>;
+    /** @internal A blocked send attempt's explanation. */
+    readonly _blocked: import("@oddkin/core/reactive").Signal<string>;
+    /** @internal Files are being dragged over. */
+    readonly _dragging: import("@oddkin/core/reactive").Signal<boolean>;
+    /** @internal */
+    get _strings(): typeof PROMPT_INPUT_STRINGS;
+    /** The composer in use (host-supplied or owned). */
+    get activeController(): ComposerController;
+    /** The draft text. Setting it never dispatches events. */
+    get value(): string;
+    set value(text: string);
+    /** The host accepted a submission; clears the submitted draft unless it was edited since. */
+    acknowledge(submissionId: string): boolean;
+    /** The host rejected a submission; the draft is kept and the error shown. */
+    fail(submissionId: string, error: PublicError): boolean;
+    /** @internal Why sending is not possible right now (empty string: just empty). */
+    _sendBlocker(state: ComposerState): string | undefined;
+    /** @internal */
+    _attachmentsAvailable(): boolean;
+    /** @internal */
+    _issue(issue: ComposerIssue): string;
+    /** @internal */
+    _bytes(size: number): string;
+    /** @internal */
+    readonly _onInput: (event: Event) => void;
+    /** @internal */
+    readonly _onCompositionStart: () => void;
+    /** @internal */
+    readonly _onCompositionEnd: () => void;
+    /** @internal */
+    readonly _onKeyDown: (event: KeyboardEvent) => void;
+    /** @internal */
+    readonly _onSubmit: (event: Event) => void;
+    /** Request submission of the draft (same as pressing Send). Returns the submission id. */
+    submit(): string | undefined;
+    /** @internal */
+    _submit(): string | undefined;
+    /** @internal */
+    readonly _stop: () => void;
+    /** @internal */
+    readonly _pick: () => void;
+    /** @internal */
+    readonly _onFiles: (event: Event) => void;
+    /** @internal */
+    readonly _onPaste: (event: ClipboardEvent) => void;
+    /** @internal */
+    readonly _onDragOver: (event: DragEvent) => void;
+    /** @internal */
+    readonly _onDragLeave: (event: DragEvent) => void;
+    /** @internal */
+    readonly _onDrop: (event: DragEvent) => void;
+    /** @internal */
+    readonly _remove: (event: Event) => void;
+    protected connected(scope: Scope): void;
+    protected updated(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'odd-prompt-input': OddkinPromptInput;
+    }
+}
+export {};
+//# sourceMappingURL=prompt-input.d.ts.map

package/dist/prompt-input/prompt-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-input.d.ts","sourceRoot":"","sources":["../../src/prompt-input/prompt-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAQ,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EACL,kBAAkB,EAClB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,4BAA4B,CAAC;AAUpC,eAAO,MAAM,oBAAoB;IAC/B,KAAK;IACL,WAAW;IACX,IAAI;IACJ,IAAI;IACJ,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,OAAO;IACP,MAAM;IACN,eAAe;IACf,iBAAiB;IACjB,WAAW;IACX,QAAQ;IACR,oBAAoB;IACpB,oBAAoB;IACpB,qBAAqB;IACrB,2BAA2B;IAC3B,QAAQ;IACR,SAAS;IACT,QAAQ;IACR,UAAU;IACV,KAAK;IACL,YAAY;IACZ,OAAO;CACR,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAkB,SAAQ,sBA+CrC;;IACA,OAAgB,iBAAiB,EAAE,cAAc,CAA0C;IAC3F,OAAgB,MAAM;QACpB,mBAAmB;QACnB,iBAAiB;;;QACjB,oBAAoB;;;QACpB,uBAAuB;;;QACvB,cAAc;MACd;IACF,SAAiB,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAInE,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,wDAAiF;IAChG,sDAAsD;IACtD,QAAQ,CAAC,QAAQ,iDAAc;IAC/B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,kDAAiB;IAEnC,gBAAgB;IAChB,IAAI,QAAQ,IAAI,OAAO,oBAAoB,CAE1C;IAED,oDAAoD;IACpD,IAAI,gBAAgB,IAAI,kBAAkB,CAEzC;IAED,0DAA0D;IAC1D,IAAI,KAAK,IAAI,MAAM,CAElB;IACD,IAAI,KAAK,CAAC,IAAI,EAAE,MAAM,EAErB;IAED,6FAA6F;IAC7F,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAEzC;IAED,6EAA6E;IAC7E,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAStD;IAED,kFAAkF;IAClF,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,CAWrD;IAED,gBAAgB;IAChB,qBAAqB,IAAI,OAAO,CAE/B;IAED,gBAAgB;IAChB,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAOnC;IAED,gBAAgB;IAChB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK3B;IAED,gBAAgB;IAChB,QAAQ,CAAC,QAAQ,UAAW,KAAK,KAAG,IAAI,CAKtC;IACF,gBAAgB;IAChB,QAAQ,CAAC,mBAAmB,QAAO,IAAI,CAErC;IACF,gBAAgB;IAChB,QAAQ,CAAC,iBAAiB,QAAO,IAAI,CAEnC;IACF,gBAAgB;IAChB,QAAQ,CAAC,UAAU,UAAW,aAAa,KAAG,IAAI,CAUhD;IACF,gBAAgB;IAChB,QAAQ,CAAC,SAAS,UAAW,KAAK,KAAG,IAAI,CAGvC;IAEF,0FAA0F;IAC1F,MAAM,IAAI,MAAM,GAAG,SAAS,CAE3B;IAED,gBAAgB;IAChB,OAAO,IAAI,MAAM,GAAG,SAAS,CA0B5B;IAED,gBAAgB;IAChB,QAAQ,CAAC,KAAK,QAAO,IAAI,CAEvB;IACF,gBAAgB;IAChB,QAAQ,CAAC,KAAK,QAAO,IAAI,CAEvB;IACF,gBAAgB;IAChB,QAAQ,CAAC,QAAQ,UAAW,KAAK,KAAG,IAAI,CAItC;IACF,gBAAgB;IAChB,QAAQ,CAAC,QAAQ,UAAW,cAAc,KAAG,IAAI,CAM/C;IACF,gBAAgB;IAChB,QAAQ,CAAC,WAAW,UAAW,SAAS,KAAG,IAAI,CAU7C;IACF,gBAAgB;IAChB,QAAQ,CAAC,YAAY,UAAW,SAAS,KAAG,IAAI,CAG9C;IACF,gBAAgB;IAChB,QAAQ,CAAC,OAAO,UAAW,SAAS,KAAG,IAAI,CAMzC;IACF,gBAAgB;IAChB,QAAQ,CAAC,OAAO,UAAW,KAAK,KAAG,IAAI,CAMrC;IA2BF,UAAmB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAe/C;IAED,UAAmB,OAAO,IAAI,IAAI,CAGjC;CACF;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,kBAAkB,EAAE,iBAAiB,CAAC;KACvC;CACF"}

package/dist/prompt-input/prompt-input.define.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="prompt-input.d.ts" preserve="true" />
+export {};
+//# sourceMappingURL=prompt-input.define.d.ts.map

package/dist/prompt-input/prompt-input.define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-input.define.d.ts","sourceRoot":"","sources":["../../src/prompt-input/prompt-input.define.ts"],"names":[],"mappings":""}

package/dist/prompt-input/prompt-input.define.js

@@ -0,0 +1,5 @@
+/// <reference path="./prompt-input.ts" preserve="true" />
+import { define } from '@oddkin/core/element';
+import { promptInputDefinition } from './prompt-input.definition.js';
+define(promptInputDefinition);
+//# sourceMappingURL=prompt-input.define.js.map

package/dist/prompt-input/prompt-input.define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-input.define.js","sourceRoot":"","sources":["../../src/prompt-input/prompt-input.define.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,MAAM,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/prompt-input/prompt-input.definition.d.ts

@@ -0,0 +1,3 @@
+import { OddkinPromptInput } from './prompt-input.js';
+export declare const promptInputDefinition: import("@oddkin/core/element").ElementDefinition<OddkinPromptInput>;
+//# sourceMappingURL=prompt-input.definition.d.ts.map

package/dist/prompt-input/prompt-input.definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-input.definition.d.ts","sourceRoot":"","sources":["../../src/prompt-input/prompt-input.definition.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAItD,eAAO,MAAM,qBAAqB,qEAMhC,CAAC"}

package/dist/prompt-input/prompt-input.definition.js

@@ -0,0 +1,14 @@
+import { buttonDefinition } from '@oddkin/components/button';
+import { compose } from '@oddkin/core/element';
+import { aiBaseStyles } from '../internal/base.styles.js';
+import { OddkinPromptInput } from './prompt-input.js';
+import { promptInputStyles } from './prompt-input.styles.js';
+import { promptInputTemplate } from './prompt-input.template.js';
+export const promptInputDefinition = compose({
+    name: 'odd-prompt-input',
+    element: OddkinPromptInput,
+    template: promptInputTemplate,
+    styles: [aiBaseStyles, promptInputStyles],
+    dependencies: { button: buttonDefinition },
+});
+//# sourceMappingURL=prompt-input.definition.js.map

package/dist/prompt-input/prompt-input.definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-input.definition.js","sourceRoot":"","sources":["../../src/prompt-input/prompt-input.definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC;IAC3C,IAAI,EAAE,kBAAkB;IACxB,OAAO,EAAE,iBAAiB;IAC1B,QAAQ,EAAE,mBAAmB;IAC7B,MAAM,EAAE,CAAC,YAAY,EAAE,iBAAiB,CAAC;IACzC,YAAY,EAAE,EAAE,MAAM,EAAE,gBAAgB,EAAE;CAC3C,CAAC,CAAC"}

package/dist/prompt-input/prompt-input.js

@@ -0,0 +1,358 @@
+import { OddkinElement, prop } from '@oddkin/core/element';
+import { signal } from '@oddkin/core/reactive';
+import { can, unavailableReason } from '../contracts/normalize.js';
+import { ComposerController, } from '../controllers/composer.js';
+import { announceEvent, attachmentAddEvent, attachmentRemoveEvent, promptStopEvent, promptSubmitEvent, } from '../events.js';
+import { format, formatNumber, langOf, strings } from '../internal/strings.js';
+export const PROMPT_INPUT_STRINGS = {
+    label: 'Message',
+    placeholder: 'Ask anything',
+    send: 'Send',
+    stop: 'Stop',
+    attach: 'Attach files',
+    remove: 'Remove {name}',
+    hintSend: 'Enter sends. Shift+Enter adds a line.',
+    hintNewline: 'Ctrl+Enter or ⌘+Enter sends. Enter adds a line.',
+    sending: 'Sending…',
+    failed: '{message} Your message was kept; you can edit it and send again.',
+    busyAttachments: 'Wait for attachments to finish uploading.',
+    failedAttachments: 'Remove or replace attachments that failed.',
+    unavailable: 'Sending is not available.',
+    dropHere: 'Drop files to attach them',
+    'ai.attachment.type': '{name} is not an accepted file type.',
+    'ai.attachment.size': '{name} is larger than {limit}.',
+    'ai.attachment.count': 'You can attach up to {limit} files.',
+    'ai.attachment.unavailable': 'Attachments are not available.',
+    selected: 'Selected',
+    uploading: 'Uploading {progress}',
+    uploaded: 'Uploaded',
+    processing: 'Processing…',
+    ready: 'Ready',
+    failedStatus: 'Failed',
+    removed: 'Removed',
+};
+/**
+ * The prompt composer: an expanding text area with attachments (button, paste, and drop),
+ * toolbar slots, send and stop, and a draft that survives failures. Submission is a cancelable
+ * request; the host acknowledges or fails it by id, and acknowledging an older submission never
+ * clears newer edits. IME composition never submits.
+ *
+ * @slot header - Content above the input (suggestions, context).
+ * @slot toolbar-start - Controls before the attach button (model picker, commands).
+ * @slot toolbar-end - Controls before the send button (voice input).
+ * @csspart form - The native form.
+ * @csspart input - The native text area.
+ * @csspart attachments - Attachment list.
+ * @csspart toolbar - Toolbar row.
+ * @csspart status - Submission status and errors.
+ * @cssprop --odd-prompt-input-max-height - Maximum height before the text area scrolls.
+ * @a11y The text area is labelled (`label`) and described by the keyboard hint, validation issues, and submission status. Send and stop are native buttons; unavailable actions explain why.
+ * @keyboard Enter sends and Shift+Enter inserts a line break (or Ctrl/⌘+Enter sends with `enter-behavior="newline"`). Keys during IME composition never send.
+ * @useFor The input of a conversation or assistant.
+ * @notFor Single-line form fields; use `odd-input`.
+ * @limitation Mentions and slash commands are host integrations through the slots and the `input` part; the composer does not parse them.
+ * @customization 1 2
+ * @category AI
+ */
+export class OddkinPromptInput extends OddkinElement.with({
+    controller: prop.object({
+        description: 'Host-owned composer controller; otherwise the element owns one.',
+    }),
+    label: prop.string({
+        default: '',
+        description: 'Accessible label; defaults to the localized "Message".',
+    }),
+    placeholder: prop.string({
+        default: '',
+        description: 'Placeholder; never a substitute for the label.',
+    }),
+    disabled: prop.boolean({ reflect: true, description: 'Prevents editing and sending.' }),
+    loading: prop.boolean({
+        reflect: true,
+        description: 'Work is running; shows Stop instead of Send when stopping is available.',
+    }),
+    attemptId: prop.string({
+        default: '',
+        attribute: 'attempt-id',
+        description: 'Attempt targeted by Stop.',
+    }),
+    capabilities: prop.object({
+        description: '`send`, `stop`, and `attachments` decide which controls are enabled.',
+    }),
+    accept: prop.string({
+        default: '',
+        description: 'Accepted attachment types (comma-separated, as `<input accept>`).',
+    }),
+    maxFileSize: prop.number({
+        default: 0,
+        attribute: 'max-file-size',
+        description: 'Maximum attachment size in bytes (0: no limit).',
+    }),
+    maxFiles: prop.number({
+        default: 0,
+        attribute: 'max-files',
+        description: 'Maximum attachments (0: no limit).',
+    }),
+    enterBehavior: prop.enum(['send', 'newline'], {
+        default: 'send',
+        attribute: 'enter-behavior',
+        description: 'What Enter does.',
+    }),
+    strings: prop.object({
+        description: 'Localized string overrides.',
+    }),
+}) {
+    static shadowRootOptions = { mode: 'open', delegatesFocus: true };
+    static events = {
+        'odd-prompt-submit': promptSubmitEvent,
+        'odd-prompt-stop': promptStopEvent,
+        'odd-attachment-add': attachmentAddEvent,
+        'odd-attachment-remove': attachmentRemoveEvent,
+        'odd-announce': announceEvent,
+    };
+    #owned;
+    #composing = false;
+    /** @internal Mirror of the composer state for the template. */
+    _state = signal({ text: '', revision: 0, attachments: [], issues: [] });
+    /** @internal A blocked send attempt's explanation. */
+    _blocked = signal('');
+    /** @internal Files are being dragged over. */
+    _dragging = signal(false);
+    /** @internal */
+    get _strings() {
+        return strings(PROMPT_INPUT_STRINGS, this.strings);
+    }
+    /** The composer in use (host-supplied or owned). */
+    get activeController() {
+        return this.controller ?? (this.#owned ??= new ComposerController());
+    }
+    /** The draft text. Setting it never dispatches events. */
+    get value() {
+        return this.activeController.getSnapshot().text;
+    }
+    set value(text) {
+        this.activeController.setText(String(text ?? ''));
+    }
+    /** The host accepted a submission; clears the submitted draft unless it was edited since. */
+    acknowledge(submissionId) {
+        return this.activeController.acknowledge(submissionId);
+    }
+    /** The host rejected a submission; the draft is kept and the error shown. */
+    fail(submissionId, error) {
+        const failed = this.activeController.fail(submissionId, error);
+        if (failed)
+            this.emit(announceEvent, {
+                text: error.message,
+                priority: 'assertive',
+                key: `submit-failed:${submissionId}`,
+            });
+        return failed;
+    }
+    /** @internal Why sending is not possible right now (empty string: just empty). */
+    _sendBlocker(state) {
+        const t = this._strings;
+        if (this.disabled)
+            return '';
+        if (!can(this.capabilities ?? { send: { available: true } }, 'send'))
+            return unavailableReason(this.capabilities, 'send') ?? t.unavailable;
+        const blocker = this.activeController.blocker();
+        if (blocker === 'attachments-busy')
+            return t.busyAttachments;
+        if (blocker === 'attachments-failed')
+            return t.failedAttachments;
+        if (blocker || (!state.text.trim() && !state.attachments.length))
+            return '';
+        if (this.loading)
+            return '';
+        return undefined;
+    }
+    /** @internal */
+    _attachmentsAvailable() {
+        return this.capabilities ? can(this.capabilities, 'attachments') : true;
+    }
+    /** @internal */
+    _issue(issue) {
+        const t = this._strings;
+        const limit = issue.code === 'ai.attachment.size' && typeof issue.limit === 'number'
+            ? this._bytes(issue.limit)
+            : String(issue.limit ?? '');
+        return format(t[issue.code], { name: issue.name, limit });
+    }
+    /** @internal */
+    _bytes(size) {
+        const locale = langOf(this);
+        if (size < 1024)
+            return `${formatNumber(size, locale)} B`;
+        if (size < 1024 * 1024)
+            return `${formatNumber(Math.round(size / 1024), locale)} KB`;
+        return `${formatNumber(Math.round(size / 104857.6) / 10, locale)} MB`;
+    }
+    /** @internal */
+    _onInput = (event) => {
+        const area = event.target;
+        this.activeController.setText(area.value);
+        this._blocked.value = '';
+        this.#resize(area);
+    };
+    /** @internal */
+    _onCompositionStart = () => {
+        this.#composing = true;
+    };
+    /** @internal */
+    _onCompositionEnd = () => {
+        this.#composing = false;
+    };
+    /** @internal */
+    _onKeyDown = (event) => {
+        if (event.key !== 'Enter')
+            return;
+        // IME: the Enter that confirms a composition must not send (keyCode 229 covers Safari).
+        if (event.isComposing || this.#composing || event.keyCode === 229)
+            return;
+        const modifier = event.ctrlKey || event.metaKey;
+        const sends = this.enterBehavior === 'send' ? !event.shiftKey && !modifier && !event.altKey : modifier;
+        if (!sends)
+            return;
+        event.preventDefault();
+        this._submit();
+    };
+    /** @internal */
+    _onSubmit = (event) => {
+        event.preventDefault();
+        this._submit();
+    };
+    /** Request submission of the draft (same as pressing Send). Returns the submission id. */
+    submit() {
+        return this._submit();
+    }
+    /** @internal */
+    _submit() {
+        const controller = this.activeController;
+        const blocker = this._sendBlocker(controller.getSnapshot());
+        if (blocker !== undefined) {
+            this._blocked.value = blocker;
+            if (blocker)
+                this.emit(announceEvent, {
+                    text: blocker,
+                    priority: 'polite',
+                    key: `blocked:${Date.now()}`,
+                });
+            return undefined;
+        }
+        const submission = controller.beginSubmit();
+        if (!submission)
+            return undefined;
+        const accepted = this.emit(promptSubmitEvent, {
+            submissionId: submission.submissionId,
+            revision: submission.revision,
+            text: submission.text,
+            attachments: submission.attachments,
+        });
+        if (!accepted) {
+            controller.cancel(submission.submissionId);
+            return undefined;
+        }
+        return submission.submissionId;
+    }
+    /** @internal */
+    _stop = () => {
+        this.emit(promptStopEvent, { attemptId: this.attemptId || undefined });
+    };
+    /** @internal */
+    _pick = () => {
+        this.shadowRoot?.querySelector('input[type="file"]')?.click();
+    };
+    /** @internal */
+    _onFiles = (event) => {
+        const input = event.target;
+        this.#add([...(input.files ?? [])]);
+        input.value = '';
+    };
+    /** @internal */
+    _onPaste = (event) => {
+        const files = [...(event.clipboardData?.files ?? [])];
+        if (!files.length)
+            return;
+        // Pasted text still pastes; pasted files become attachments.
+        if (!event.clipboardData?.getData('text'))
+            event.preventDefault();
+        this.#add(files);
+    };
+    /** @internal */
+    _onDragOver = (event) => {
+        if (!event.dataTransfer?.types.includes('Files') ||
+            !this._attachmentsAvailable() ||
+            this.disabled)
+            return;
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'copy';
+        this._dragging.value = true;
+    };
+    /** @internal */
+    _onDragLeave = (event) => {
+        if (!event.relatedTarget || !this.shadowRoot?.contains(event.relatedTarget))
+            this._dragging.value = false;
+    };
+    /** @internal */
+    _onDrop = (event) => {
+        this._dragging.value = false;
+        const files = [...(event.dataTransfer?.files ?? [])];
+        if (!files.length)
+            return;
+        event.preventDefault();
+        this.#add(files);
+    };
+    /** @internal */
+    _remove = (event) => {
+        const attachmentId = event.currentTarget.dataset['id'];
+        if (!attachmentId)
+            return;
+        this.activeController.removeAttachment(attachmentId);
+        this.emit(attachmentRemoveEvent, { attachmentId });
+        this.shadowRoot?.querySelector('textarea')?.focus();
+    };
+    #add(files) {
+        if (!files.length || this.disabled)
+            return;
+        const controller = this.activeController;
+        controller.configure({
+            accept: this.accept ? this.accept.split(',') : [],
+            ...(this.maxFileSize > 0 ? { maxFileSize: this.maxFileSize } : {}),
+            ...(this.maxFiles > 0 ? { maxFiles: this.maxFiles } : {}),
+            attachments: this._attachmentsAvailable(),
+        });
+        const added = controller.addFiles(files);
+        if (added.length)
+            this.emit(attachmentAddEvent, { attachments: added });
+        const issues = controller.getSnapshot().issues;
+        if (issues.length)
+            this.emit(announceEvent, {
+                text: issues.map((i) => this._issue(i)).join(' '),
+                priority: 'polite',
+                key: `issues:${Date.now()}`,
+            });
+    }
+    #resize(area) {
+        area.style.blockSize = 'auto';
+        area.style.blockSize = `${area.scrollHeight}px`;
+    }
+    connected(scope) {
+        scope.effect((run) => {
+            const controller = this.activeController;
+            controller.restorePreviews();
+            const state = controller.state;
+            run.effect(() => {
+                this._state.value = state.value;
+            });
+            // Owned previews are view resources: released while disconnected, recreated on reconnect.
+            if (controller === this.#owned)
+                run.add(() => controller.releasePreviews(), 'composer previews');
+        }, { name: '<odd-prompt-input> composer' });
+    }
+    updated() {
+        const area = this.shadowRoot?.querySelector('textarea');
+        if (area)
+            this.#resize(area);
+    }
+}
+//# sourceMappingURL=prompt-input.js.map