@jangts/agent-core 0.3.6 → 0.5.0

package/dist/esm/structs/capabilities/tools.d.ts

@@ -5,7 +5,7 @@
  * registry binds an App context, validates input/output at the boundary and produces receipts, so
  * individual tools never handle transportation, budget accounting or event emission.
  *
- * Exports: `ToolDefinition`, `ToolExecutionContext`, `ExecutableTool`, `RegisteredTool`,
+ * Exports: `ToolDefinition`, `ToolExecutionContext`, `ErasedTool`, `RegisteredTool`,
  * `ToolExecutionEvent`, `ToolRegistryPorts`, `ToolInvocationRequest`, `ToolRegistryOptions`.
  */
 import type { InvocationMetadata } from '../invocation.js';
@@ -13,8 +13,9 @@ import type { ExecutionContext, MaybePromise, OperationContext, SchemaAdapter }
 import type { DiagnosticContext } from '../diagnostics.js';
 import type { RegistrationProjection } from '../../utils/registration.js';
 import type { NodeReportingContext } from '../debug.js';
+import type { ModelTool, ToolProposal } from './model.js';
 /** One registered tool, typed by its input, output, host context and id literal. */
-export interface ToolDefinition<Input = unknown, Output = unknown, App = unknown, Id extends string = string> {
+export interface ExecutableTool<Input = unknown, Output = unknown, App = unknown, Id extends string = string> extends ModelTool<Input, ToolProposal, App> {
     /** Stable id; also the name the model calls. */
     readonly id: Id;
     /** Declared grouping used by registries and documentation; not an authorization boundary. */
@@ -32,6 +33,10 @@ export interface ToolDefinition<Input = unknown, Output = unknown, App = unknown
     /** Validates untrusted output (for example a cached replay) before it is returned. */
     parseOutput(value: unknown): Output;
 }
+/** Configuration form; Support supplies the identity resolver when omitted. */
+export type ToolDefinition<Input = unknown, Output = unknown, App = unknown, Id extends string = string> = Omit<ExecutableTool<Input, Output, App, Id>, 'resolve'> & {
+    readonly resolve?: ExecutableTool<Input, Output, App, Id>['resolve'];
+};
 /** Execution facts handed to a tool for one invocation. */
 export interface ToolExecutionContext extends ExecutionContext, NodeReportingContext {
     /** Delegate bound by Core to this actual invocation. */
@@ -46,7 +51,7 @@ export interface ToolExecutionContext extends ExecutionContext, NodeReportingCon
     readonly signal: AbortSignal;
 }
 /** Type-erased tool shape the registry executes after parsing at the boundary. */
-export interface ExecutableTool {
+export interface ErasedTool {
     readonly id: string;
     readonly kind: string;
     /** Optional here because the erased view does not require model-facing prose. */
@@ -57,7 +62,7 @@ export interface ExecutableTool {
     execute(input: unknown, context: ToolExecutionContext): unknown;
 }
 /** Registered snapshot: public data is retained, implementation helpers are not a contract. */
-export type RegisteredTool<Tool extends ExecutableTool = ExecutableTool> = RegistrationProjection<Tool, ExecutableTool>;
+export type RegisteredTool<Tool extends ErasedTool = ErasedTool> = RegistrationProjection<Tool, ErasedTool>;
 /** Fact emitted when one tool call settles, correlated by `invocationId`. */
 export interface ToolExecutionEvent<Kind extends string = string> extends InvocationMetadata {
     toolId: string;

package/dist/esm/structs/common.d.ts

@@ -107,7 +107,7 @@ export interface ExecutionContext {
  * it as opaque and must not depend on application-specific fields.
  */
 export interface OperationContext<App = unknown> extends ExecutionContext {
-    readonly app: Readonly<App>;
+    readonly app: unknown extends App ? App : Readonly<App>;
 }
 /**
  * One search result.

package/dist/esm/structs/index.d.ts

@@ -2,9 +2,9 @@
  * Public entry of the structs layer.
  *
  * Structs are the shape-only half of agent-core: declarations and frozen constant catalogs that the
- * runtime modules (`capabilities`, `context`, `execution`, `model`, `kits`, `support`) both
- * implement and consume. Runtime classes declared here only describe shape or initialize fields,
- * so importing this barrel never starts execution.
+ * runtime modules (`tools`, `context`, `execution`, `model`, `kits`, `support`) both implement and
+ * consume. Runtime classes declared here only describe shape or initialize fields, so importing this
+ * barrel never starts execution.
  *
  * Exports: a curated re-export of the shared vocabulary, error classes, diagnostics/event
  * envelopes, model and workflow contracts, and the optional Kit protocol definitions.
@@ -19,6 +19,7 @@ export * from './model/interactions.js';
 export * from './context/journal.js';
 export * from './support/transport/json.js';
 export * from './model/messages.js';
+export * from './model/session.js';
 export * from './model/runtime.js';
 export * from './support/model/provider.js';
 export * from './kits/interaction.js';
@@ -32,10 +33,10 @@ export * from './kits/evidence.js';
 export * from './kits/presentation/templates.js';
 export * from './kits/retrieval.js';
 export * from './kits/text-skills.js';
-export * from './kits/intents/registry.js';
-export * from './kits/intents/scopes.js';
+export * from './kits/domains/registry.js';
+export * from './kits/domains/scopes.js';
 export * from './kits/tools.js';
-export * from './kits/intents/catalog.js';
+export * from './kits/domains/catalog.js';
 export * from './support/registration.js';
 export * from './diagnostics.js';
 export * from './support/context.js';

package/dist/esm/structs/index.js

@@ -2,9 +2,9 @@
  * Public entry of the structs layer.
  *
  * Structs are the shape-only half of agent-core: declarations and frozen constant catalogs that the
- * runtime modules (`capabilities`, `context`, `execution`, `model`, `kits`, `support`) both
- * implement and consume. Runtime classes declared here only describe shape or initialize fields,
- * so importing this barrel never starts execution.
+ * runtime modules (`tools`, `context`, `execution`, `model`, `kits`, `support`) both implement and
+ * consume. Runtime classes declared here only describe shape or initialize fields, so importing this
+ * barrel never starts execution.
  *
  * Exports: a curated re-export of the shared vocabulary, error classes, diagnostics/event
  * envelopes, model and workflow contracts, and the optional Kit protocol definitions.
@@ -19,6 +19,7 @@ export * from './model/interactions.js';
 export * from './context/journal.js';
 export * from './support/transport/json.js';
 export * from './model/messages.js';
+export * from './model/session.js';
 export * from './model/runtime.js';
 export * from './support/model/provider.js';
 export * from './kits/interaction.js';
@@ -32,10 +33,10 @@ export * from './kits/evidence.js';
 export * from './kits/presentation/templates.js';
 export * from './kits/retrieval.js';
 export * from './kits/text-skills.js';
-export * from './kits/intents/registry.js';
-export * from './kits/intents/scopes.js';
+export * from './kits/domains/registry.js';
+export * from './kits/domains/scopes.js';
 export * from './kits/tools.js';
-export * from './kits/intents/catalog.js';
+export * from './kits/domains/catalog.js';
 export * from './support/registration.js';
 export * from './diagnostics.js';
 export * from './support/context.js';

package/dist/esm/structs/kits/answering/tasks.d.ts

@@ -16,8 +16,8 @@ export interface AnswerTaskDefinition<Input = unknown, Data = unknown> {
     readonly readerId: string;
     /** Output contract the answer must satisfy; must be registered. */
     readonly outputId: string;
-    /** Intents this task serves; non-empty. */
-    readonly intentIds: readonly string[];
+    /** Goals this task serves; non-empty. */
+    readonly goalIds: readonly string[];
     /** Optional scope narrowing the task. */
     readonly scopeId?: string;
     /** Checks applied to the produced value; every id must be registered. */

package/dist/esm/structs/kits/{intents → domains}/catalog.d.ts

@@ -1,26 +1,26 @@
 /**
- * Agent catalog contract for the Intents Kit.
+ * Agent catalog contract for the Domain Tools Kit.
  *
  * Place in the package: an optional App-side projection that describes which intents, scopes and
  * tools are available to one request. The ports read the App's real registries, so no parallel
  * capability list exists; this module only declares what the catalog needs from them.
  *
- * Exports: `CatalogIntent`, `CatalogScope`, `CatalogTask`, `CatalogTool`, `DescribedTool`,
+ * Exports: `CatalogGoal`, `CatalogScope`, `CatalogTask`, `CatalogTool`, `DescribedTool`,
  * `AgentCatalogPorts`.
  */
-/** Intent as the catalog sees it: an id plus its declared steps. */
-export interface CatalogIntent<Id extends string = string> {
+/** Goal as the catalog sees it: an id plus its declared delegates. */
+export interface CatalogGoal<Id extends string = string> {
     readonly id: Id;
-    readonly steps: readonly string[];
+    readonly delegates: readonly string[];
 }
 /** Scope as the catalog sees it: an id plus the tools it may use. */
 export interface CatalogScope {
     readonly id: string;
     readonly toolIds: readonly string[];
 }
-/** The task currently accepted for the request, used to narrow the catalog. */
+/** The goal currently accepted for the request, used to narrow the catalog. */
 export interface CatalogTask<Id extends string = string> {
-    readonly intentId: Id;
+    readonly goalId: Id;
     /** Selected scope; `null` or `undefined` means a scope has not been chosen yet. */
     readonly scopeId?: string | null;
 }
@@ -28,12 +28,12 @@ export interface CatalogTask<Id extends string = string> {
 export interface CatalogTool<App> {
     readonly id: string;
     /** Intent ids the tool serves, or `'all'` when it is always available. */
-    readonly intentIds: 'all' | readonly string[];
+    readonly goalIds: 'all' | readonly string[];
     /** Returns whether the tool may run for this App state; absent means always available. */
-    available?(app: App): boolean;
-    /** Invocation step, when the tool participates in the step-based lifecycle. */
-    readonly invocation?: {
-        readonly step: string;
+    readonly active?: import('../../capabilities/model.js').ToolCondition<App>;
+    /** Invocation identity, when the tool participates in the lifecycle. */
+    readonly lifecycle?: {
+        readonly id?: string;
     };
 }
 /** Model- or host-facing description of one tool. */
@@ -43,15 +43,15 @@ export interface DescribedTool {
     readonly description: string;
     readonly audience: string;
     readonly effect: string;
-    readonly intentIds: readonly string[];
+    readonly goalIds: readonly string[];
 }
 /** Ports the catalog reads from the App's registries. */
-export interface AgentCatalogPorts<App, Id extends string, Intent extends CatalogIntent<Id>, Scope extends CatalogScope> {
-    /** All registered intent ids, before availability filtering. */
-    intentIds(): readonly Id[];
-    /** Registered intents, optionally narrowed to `ids`. */
-    intents(ids?: readonly Id[]): readonly Intent[];
-    /** Registered scopes for the given intent ids (all scopes when omitted). */
+export interface AgentCatalogPorts<App, Id extends string, Intent extends CatalogGoal<Id>, Scope extends CatalogScope> {
+    /** All registered Tool ids, before availability filtering. */
+    goalIds(app: App): readonly Id[];
+    /** Registered domain Tools, optionally narrowed to `ids`. */
+    goals(ids?: readonly Id[]): readonly Intent[];
+    /** Registered scopes for the given Tool ids (all scopes when omitted). */
     scopes(ids?: readonly Id[]): readonly Scope[];
     /** When not `false`, the catalog is narrowed to `currentTask`; defaults to restriction on. */
     readonly restrictToTask?: boolean;
@@ -60,7 +60,7 @@ export interface AgentCatalogPorts<App, Id extends string, Intent extends Catalo
     readonly tools: {
         values(): Iterable<CatalogTool<App>>;
         has(id: string): boolean;
-        supportsIntent(id: Id, app: App): boolean;
+        supportsGoal(id: Id, app: App): boolean;
         /** Describes tools for an audience (for example `'model'`); must be synchronous. */
         describe(audience?: string, app?: App): readonly DescribedTool[];
     };

package/dist/esm/structs/kits/{intents → domains}/registry.d.ts

@@ -1,23 +1,24 @@
 /**
- * Intent registry contract for the Intents Kit.
+ * Domain Tool registry contract for the Domain Tools Kit.
  *
- * Place in the package: an optional App-side catalog of model intents. An intent names its ordered
- * steps and optional App-declared policies; the registry checks identity, allowed vocabulary,
+ * Place in the package: an optional App-side catalog of domain Tools. An intent names its allowed
+ * delegates and optional App-declared policies; the registry checks identity, allowed vocabulary,
  * duplicate ids and sealing, while the meaning of each vocabulary value stays with the App.
  *
- * Exports: `IntentDefinition`, `IntentRegistryPolicy`, `IntentDescription`, `IntentId`,
+ * Exports: `IntentTool`, `IntentPolicy`, `IntentDescription`, `IntentId`,
  * `RegisteredIntent`.
  */
 import type { BreakReason } from '../../utils/rules.js';
 import type { RegistrationProjection } from '../../../utils/registration.js';
-/** One declarable intent. */
-export interface IntentDefinition {
-    /** Unique intent id, matched against the policy's `idPattern` when configured. */
+import type { ModelTool } from '../../capabilities/model.js';
+/** One domain Tool. */
+export interface IntentTool extends ModelTool<any, any> {
+    /** Unique Tool id, matched against the policy's `idPattern` when configured. */
     id: string;
     /** Non-blank model-facing description. */
     description: string;
-    /** Ordered step ids; non-empty, unique and, when `policy.steps` is set, drawn from it. */
-    steps: readonly string[];
+    /** Allowed delegate ids, retained in declaration order without imposing execution order; non-empty and unique. */
+    delegates?: readonly string[];
     /** App-declared scope-mode name; validated against `policy.scopeModes` when that is set. */
     scopePolicy?: string;
     /** App-declared target-mode name; validated against `policy.targetModes` when that is set. */
@@ -31,9 +32,11 @@ export interface IntentDefinition {
     /** App-declared handoff marker; validated against `policy.handoffValues` when that is set. */
     preparedHandoff?: unknown;
 }
+/** Configuration form; object arguments and a Tool proposal are the registration defaults. */
+export type IntentToolRegistration = Omit<IntentTool, 'inputSchema' | 'resolve'> & Partial<Pick<IntentTool, 'inputSchema' | 'resolve'>>;
 /** Registration rules for one intent registry. */
-export interface IntentRegistryPolicy<Definition extends IntentDefinition> {
-    /** Pattern every intent id must match. */
+export interface IntentPolicy<Definition extends IntentToolRegistration> {
+    /** Pattern every Tool id must match. */
     readonly idPattern?: RegExp;
     /** Allowed `scopePolicy` values; `undefined` accepts any value. */
     readonly scopeModes?: readonly string[];
@@ -43,8 +46,8 @@ export interface IntentRegistryPolicy<Definition extends IntentDefinition> {
     readonly contextTiers?: readonly string[];
     /** Allowed `planIntent` values; `undefined` accepts any value. */
     readonly actions?: readonly string[];
-    /** Allowed step ids; `undefined` accepts any non-empty step. */
-    readonly steps?: readonly string[];
+    /** Allowed delegate ids; `undefined` accepts any non-empty delegate. */
+    readonly delegates?: readonly string[];
     /** Allowed `preparedHandoff` values; `undefined` accepts any value. */
     readonly handoffValues?: readonly unknown[];
     /** Extra App assertion, called after the built-in checks; must return void synchronously. */
@@ -54,24 +57,24 @@ export interface IntentRegistryPolicy<Definition extends IntentDefinition> {
     readonly errors?: {
         readonly sealed?: BreakReason;
         readonly invalid?: BreakReason;
-        /** Builds the duplicate-id rejection; receives the intent id. */
+        /** Builds the duplicate-id rejection; receives the Tool id. */
         readonly duplicate?: (goal: string) => Error | string;
     };
 }
-/** Registered intent with its steps widened to the definition's step literals. */
-export type IntentDescription<Definition extends IntentDefinition> = Omit<RegisteredIntent<Definition>, 'steps'> & {
-    steps: Definition['steps'][number][];
+/** Registered domain Tool with its delegates widened to the definition's delegate literals. */
+export type IntentDescription<Definition extends IntentToolRegistration> = Omit<RegisteredIntent<Definition>, 'delegates'> & {
+    delegates: NonNullable<Definition['delegates']>[number][];
 };
 /** Union of the ids of a definition set, or `string` when it cannot be narrowed. */
 export type IntentId<Definition> = Definition extends {
     id: infer Id extends string;
 } ? Id : string;
-type RegisteredIntentLists<Definition extends IntentDefinition> = {
-    readonly [Key in keyof Pick<Definition, Extract<keyof Definition, 'steps' | 'auxiliaryActions'>>]: Readonly<Definition[Key]>;
+type RegisteredIntentLists<Definition extends IntentToolRegistration> = {
+    readonly [Key in keyof Pick<Definition, Extract<keyof Definition, 'delegates' | 'auxiliaryActions'>>]: Readonly<Definition[Key]>;
 };
 /** Frozen registration view: list fields are frozen copies, helper methods are dropped. */
-export type RegisteredIntent<Definition extends IntentDefinition> = Readonly<Omit<RegistrationProjection<Definition, IntentDefinition>, 'steps' | 'auxiliaryActions'> & RegisteredIntentLists<Definition> & {
+export type RegisteredIntent<Definition extends IntentToolRegistration> = Readonly<Omit<RegistrationProjection<Definition, IntentTool>, 'delegates' | 'auxiliaryActions' | 'inputSchema' | 'resolve'> & ModelTool<any, any> & RegisteredIntentLists<Definition> & {
     id: Definition['id'];
-    steps: Readonly<Definition['steps']>;
+    delegates: Readonly<NonNullable<Definition['delegates']>>;
 }>;
 export {};

package/dist/esm/structs/kits/{intents → domains}/scopes.d.ts

@@ -1,5 +1,5 @@
 /**
- * Scope registry contract for the Intents Kit.
+ * Scope registry contract for the Domain Tools Kit.
  *
  * Place in the package: an optional App-side catalog of scope definitions. A scope binds an intent
  * to the sources and tools it may use; the registry validates identity, aliases, required bindings
@@ -19,8 +19,8 @@ export interface ScopeDefinition {
     description: string;
     /** Scope category; validated against `policy.categories` when that is set. */
     category: string;
-    /** Intents this scope serves; required when the policy sets `requireIntents`. */
-    intentIds?: readonly string[];
+    /** Goals this scope serves; required when the policy sets `requireGoals`. */
+    goalIds?: readonly string[];
     /** Referenced query scopes, resolved by the App. */
     queryScopeIds?: readonly string[];
     /** Referenced knowledge topics, resolved by the App. */
@@ -36,8 +36,8 @@ export interface ScopeDefinition {
 }
 /** Registration rules for one scope registry. */
 export interface ScopeRegistryPolicy<Definition extends ScopeDefinition> {
-    /** Require at least one intent id per scope. */
-    readonly requireIntents?: boolean;
+    /** Require at least one Tool id per scope. */
+    readonly requireGoals?: boolean;
     /** Require at least one query scope or knowledge topic per scope. */
     readonly requireSources?: boolean;
     /** Require at least one tool id per scope. */
@@ -49,7 +49,7 @@ export interface ScopeRegistryPolicy<Definition extends ScopeDefinition> {
     /** Extra App assertion, called after the built-in checks; must return void synchronously. */
     readonly assertDefinition?: (definition: Definition) => void;
     /** Replaces the default intent membership test; must return boolean synchronously. */
-    readonly acceptsIntent?: (definition: Readonly<Definition>, goal: string) => boolean;
+    readonly acceptsTool?: (definition: Readonly<Definition>, goal: string) => boolean;
     /** Diagnostic tags attached to registration rejections. */
     readonly tags?: readonly string[];
     readonly errors?: {
@@ -59,7 +59,7 @@ export interface ScopeRegistryPolicy<Definition extends ScopeDefinition> {
 }
 /** Registered evidence entry: public data only, frozen by the registry. */
 export type RegisteredScopeEvidence<Definition extends ScopeDefinition> = Readonly<RegistrationData<NonNullable<Definition['evidence']>[number]>>;
-type ScopeListKey = 'intentIds' | 'queryScopeIds' | 'knowledgeTopicIds' | 'toolIds' | 'aliases';
+type ScopeListKey = 'goalIds' | 'queryScopeIds' | 'knowledgeTopicIds' | 'toolIds' | 'aliases';
 type RegisteredScopeLists<Definition extends ScopeDefinition> = {
     readonly [Key in ScopeListKey]: [NonNullable<Definition[Key]>] extends [never] ? readonly [] : NonNullable<Definition[Key]> extends readonly string[] ? Readonly<NonNullable<Definition[Key]>> : readonly string[];
 };
@@ -74,8 +74,8 @@ export type RegisteredScope<Definition extends ScopeDefinition> = Readonly<Omit<
     evidence: ScopeEvidenceList<Definition>;
 }>;
 /** Plain description with mutable arrays, for documentation and model-facing catalogs. */
-export type ScopeDescription<Definition extends ScopeDefinition> = Omit<RegisteredScope<Definition>, 'intentIds' | 'queryScopeIds' | 'knowledgeTopicIds' | 'toolIds' | 'aliases' | 'evidence'> & {
-    intentIds: string[];
+export type ScopeDescription<Definition extends ScopeDefinition> = Omit<RegisteredScope<Definition>, 'goalIds' | 'queryScopeIds' | 'knowledgeTopicIds' | 'toolIds' | 'aliases' | 'evidence'> & {
+    goalIds: string[];
     queryScopeIds: string[];
     knowledgeTopicIds: string[];
     toolIds: string[];

package/dist/esm/structs/kits/presentation/formats.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Reply-format contract for the Presentation Kit.
+ *
+ * A format exists only where the App provides a template for the final reply. Replies without a
+ * resolved format have no output-format requirement, so callers skip these checks instead of
+ * re-asking the model.
+ *
+ * Exports: `ReplyFormatCheck`, `ReplyFormatDefinition`, `CompiledReplyFormat`, `ReplyFormatOptions`.
+ */
+/** One check a template declares, evaluated against the rendered bubbles. */
+export interface ReplyFormatCheck {
+    /** Stable check id referenced by formats. */
+    readonly id: string;
+    /** Human-readable statement of the template requirement. */
+    readonly description: string;
+    /** Returns whether the reply satisfies this requirement. */
+    readonly accepts: (bubbles: readonly string[]) => boolean;
+}
+/** A template-bound reply format, matched against per-turn facts. */
+export interface ReplyFormatDefinition<Context = unknown> {
+    /** Stable format id. */
+    readonly id: string;
+    /** Human-readable statement of the template. */
+    readonly description: string;
+    /** Check ids this template requires. */
+    readonly checks: readonly string[];
+    /** Whether the current turn uses this template. */
+    readonly when: (context: Context) => boolean;
+}
+/** A resolved format with its checks bound; callers only inspect replies using it. */
+export interface CompiledReplyFormat {
+    readonly id: string;
+    readonly description: string;
+    readonly checks: readonly string[];
+    /** Checks the reply fails; empty means the template format is satisfied. */
+    readonly inspect: (bubbles: readonly string[]) => readonly ReplyFormatCheck[];
+}
+/** Declaration input for `defineReplyFormats`. */
+export interface ReplyFormatOptions<Context = unknown> {
+    readonly formats: readonly ReplyFormatDefinition<Context>[];
+    readonly checks: readonly ReplyFormatCheck[];
+}

package/dist/esm/structs/kits/presentation/formats.js

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

package/dist/esm/structs/kits/text-blocks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Text block contract for the Text Blocks Kit.
+ *
+ * Place in the package: an optional App-side helper for splitting long plain text into
+ * structure-aware blocks before paging or retrieval. File reading, paging, search, storage
+ * and prompt wording stay with the App.
+ *
+ * Exports: `TextBlock`, `TextBlockOptions`.
+ */
+/** One structure-aware block of a long text. */
+export interface TextBlock {
+    /** One-based position in source order; stable for a given text and target size. */
+    readonly number: number;
+    /** Exact source substring, including its own line endings. */
+    readonly text: string;
+    /** Start offset in UTF-16 code units. */
+    readonly start: number;
+    /** End offset (exclusive) in UTF-16 code units; `end - start === text.length`. */
+    readonly end: number;
+}
+/** Splitting options. */
+export interface TextBlockOptions {
+    /** Target block size in characters; only a single over-long line may exceed it. */
+    readonly targetChars: number;
+}

package/dist/esm/structs/kits/text-blocks.js

@@ -0,0 +1,10 @@
+/**
+ * Text block contract for the Text Blocks Kit.
+ *
+ * Place in the package: an optional App-side helper for splitting long plain text into
+ * structure-aware blocks before paging or retrieval. File reading, paging, search, storage
+ * and prompt wording stay with the App.
+ *
+ * Exports: `TextBlock`, `TextBlockOptions`.
+ */
+export {};