theorum 0.1.15 → 1.1.3

package/esm/src/kernel/registry/catalog.js

@@ -1,86 +1,10 @@
 /**
- * Tool catalog and MIME helpers.
- *
- * Model wire metadata is host-owned on `profile.model.config`. This module only
- * keeps builtin/custom tool descriptors and shared MIME utilities.
+ * MIME helpers and model binding utilities.
  *
  * @module
  */
 import { TheorumError } from '../../guardrails/error.js';
-const ASK_USER_SCHEMA = {
-    type: 'object',
-    properties: {
-        kind: { type: 'string', enum: ['confirm', 'choice', 'text'] },
-        prompt: { type: 'string' },
-        options: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['kind', 'prompt'],
-};
-/** Harness tools that always ship with THEORUM. */
-const HARNESS_TOOLS = {
-    askUser: { kind: 'custom', ui: true, schema: ASK_USER_SCHEMA },
-};
-/** Live tool catalog. Starts with harness tools; presets/hosts register more. */
-const CATALOG = {
-    tools: { ...HARNESS_TOOLS },
-};
-/** Register or replace tool descriptors (idempotent per id). */
-function registerTools(entries) {
-    Object.assign(CATALOG.tools, entries);
-}
-/** Look up one registered tool descriptor. */
-function getTool(id) {
-    return CATALOG.tools[id];
-}
-/** Ids of all registered provider builtins. */
-function listBuiltinIds() {
-    return Object.entries(CATALOG.tools)
-        .filter(([, entry]) => entry.kind === 'builtin')
-        .map(([id]) => id);
-}
-/** Restore harness-only tools (tests / host reloads). */
-function resetTools() {
-    for (const id of Object.keys(CATALOG.tools)) {
-        delete CATALOG.tools[id];
-    }
-    Object.assign(CATALOG.tools, HARNESS_TOOLS);
-}
-/** MIME essence → normalized media part category (shared ingress map). */
-const MEDIA_INPUT_KINDS = {
-    'image/png': 'image',
-    'image/jpeg': 'image',
-    'image/jpg': 'image',
-    'image/webp': 'image',
-    'image/heic': 'image',
-    'image/heif': 'image',
-    'audio/wav': 'audio',
-    'audio/x-wav': 'audio',
-    'audio/mpeg': 'audio',
-    'audio/mp3': 'audio',
-    'audio/aiff': 'audio',
-    'audio/aac': 'audio',
-    'audio/ogg': 'audio',
-    'audio/flac': 'audio',
-    'audio/webm': 'audio',
-    'audio/mp4': 'audio',
-    'audio/pcm': 'audio',
-    'video/mp4': 'video',
-    'video/mpeg': 'video',
-    'video/quicktime': 'video',
-    'video/x-msvideo': 'video',
-    'video/x-flv': 'video',
-    'video/mpg': 'video',
-    'video/webm': 'video',
-    'video/wmv': 'video',
-    'video/x-ms-wmv': 'video',
-    'video/3gpp': 'video',
-    'application/pdf': 'document',
-    'text/plain': 'document',
-    'text/csv': 'document',
-    'text/markdown': 'document',
-    'text/html': 'document',
-    'application/json': 'document',
-};
+import { MEDIA_INPUT_KINDS } from '../schema.js';
 function mimeEssence(mime) {
     const [base] = mime.split(';');
     return (base ?? '').trim().toLowerCase();
@@ -98,38 +22,73 @@ function mimeAllowed(accept, mime) {
 function mediaKindForMime(mime) {
     return MEDIA_INPUT_KINDS[mimeEssence(mime)];
 }
-/** Require a host-declared model spec for an allowed profile model id. */
-function requireModelSpec(profile, modelId) {
-    const spec = profile.model.config[modelId];
-    if (!spec) {
-        throw new TheorumError(`Profile ${profile.id} has no model spec for '${modelId}'`);
+/** The `accept` list a profile declares for one input channel, if it declares one. */
+function profileAccept(profile, channel) {
+    if (profile.type === 'speech' || profile.type === 'live' || profile.type === 'host') {
+        return undefined;
+    }
+    const inputs = profile.inputs;
+    return channel === 'voice' ? inputs?.voice?.accept : inputs?.attachments?.accept;
+}
+/**
+ * Which `TurnInput` channel of a profile accepts this MIME, or `undefined` when
+ * the profile accepts it nowhere (or the kernel cannot classify it at all).
+ *
+ * The one public answer to "does this profile take this file". Hosts route and
+ * filter channel ingress with it instead of keeping their own MIME table: the
+ * profile's `accept` lists are the whole declaration.
+ */
+function mediaChannelForMime(profile, mime) {
+    if (!mediaKindForMime(mime)) {
+        return undefined;
+    }
+    for (const channel of ['attachments', 'voice']) {
+        const accept = profileAccept(profile, channel);
+        if (accept && mimeAllowed(accept, mime)) {
+            return channel;
+        }
+    }
+    return undefined;
+}
+/** Require a host-declared model binding for a profile model id. */
+function requireModelBinding(profile, modelId) {
+    const binding = profile.models[modelId];
+    if (!binding) {
+        throw new TheorumError(`Profile ${profile.id} has no model binding for '${modelId}'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    return binding;
+}
+function effortLevels(binding) {
+    if (!binding?.efforts) {
+        return [];
     }
-    return spec;
+    return Object.values(binding.efforts);
 }
-function clampLevels(entry, level) {
-    if (!entry?.thinkingLevels || entry.thinkingLevels.length === 0) {
+function clampLevels(binding, level) {
+    const legal = effortLevels(binding);
+    if (legal.length === 0) {
         return level;
     }
-    if (entry.thinkingLevels.includes(level)) {
+    if (legal.includes(level)) {
         return level;
     }
-    const fallback = entry.thinking.off;
-    if (entry.thinkingLevels.includes(fallback)) {
+    const fallbackAlias = binding?.defaultEffort;
+    const fallback = fallbackAlias ? binding?.efforts?.[fallbackAlias] : undefined;
+    if (fallback && legal.includes(fallback)) {
         return fallback;
     }
-    const first = entry.thinkingLevels[0];
-    return first ?? level;
+    return legal[0] ?? level;
 }
-/** Clamp a requested thinking level to what the model spec accepts. */
-function clampThinkingLevel(spec, level) {
-    return clampLevels(spec, level);
+/** Clamp a requested thinking level to what the model binding accepts. */
+function clampThinkingLevel(binding, level) {
+    return clampLevels(binding, level);
 }
-/** Look up a model spec by provider-native API id within a host specs map. */
-function modelEntryByApiId(specs, apiId) {
-    return Object.values(specs).find((m) => m.apiId === apiId);
+/** Look up a model binding by provider-native API id within a host map. */
+function modelEntryByApiId(bindings, apiId) {
+    return Object.values(bindings).find((m) => m.apiId === apiId);
 }
-/** Clamp thinking level using a provider-native API id within a host specs map. */
-function clampThinkingLevelForApiId(specs, apiId, level) {
-    return clampLevels(modelEntryByApiId(specs, apiId), level);
+/** Clamp thinking level using a provider-native API id within a host map. */
+function clampThinkingLevelForApiId(bindings, apiId, level) {
+    return clampLevels(modelEntryByApiId(bindings, apiId), level);
 }
-export { CATALOG, clampThinkingLevel, clampThinkingLevelForApiId, getTool, listBuiltinIds, mediaKindForMime, mimeAllowed, mimeEssence, modelEntryByApiId, registerTools, requireModelSpec, resetTools, };
+export { clampThinkingLevel, clampThinkingLevelForApiId, mediaChannelForMime, mediaKindForMime, mimeAllowed, mimeEssence, modelEntryByApiId, profileAccept, requireModelBinding, };

package/esm/src/kernel/registry/ingress.d.ts

@@ -5,9 +5,14 @@
  *
  * @module
  */
-import type { BuiltinToolId, ImageResponseFormat, InteractionPart, ModelId, Profile, TurnRequest } from '../types.js';
+import type { ImageResponseFormat, InteractionPart, ModelId, Profile, TurnRequest } from '../types.js';
+/**
+ * Provider wire formats (JSON schema, image, speech) are mutually exclusive.
+ * Typed profiles make illegal mixes unrepresentable; this remains a safety net
+ * for responseFormat structured on text vs accidental dual modes.
+ */
+declare function assertOutputMode(profile: Profile, structuredId: string | null): void;
 declare function assertSpeechRole(profile: Profile): void;
-declare function resolveImageFormat(profile: Profile, _model: ModelId, slots?: Record<string, string>): ImageResponseFormat | null;
+declare function resolveImageFormat(profile: Profile): ImageResponseFormat | null;
 declare function resolveInputParts(profile: Profile, model: ModelId, req: TurnRequest): InteractionPart[];
-declare function assertImageGrounding(profile: Profile, model: ModelId, builtins: BuiltinToolId[]): void;
-export { assertImageGrounding, assertSpeechRole, resolveImageFormat, resolveInputParts };
+export { assertOutputMode, assertSpeechRole, resolveImageFormat, resolveInputParts };

package/esm/src/kernel/registry/ingress.js

@@ -5,119 +5,139 @@
  *
  * @module
  */
+import { wrapUserData } from '../../guardrails/canary.js';
 import { TheorumError } from '../../guardrails/error.js';
-import { wrapUserData } from '../engine/boundary.js';
 import { synthesizeRepairPrompt } from '../engine/repair.js';
-import { assertAttachmentLimits, requireMediaLimits } from './attachments.js';
-import { mediaKindForMime, mimeAllowed, mimeEssence } from './catalog.js';
-function listedValue(allowed, value) {
-    if (!value) {
-        return undefined;
+import { isSpeechFormatAllowedForProtocol } from '../schema.js';
+import { assertAttachmentLimits, isTurnMediaRef, requireMediaLimits } from './attachments.js';
+import { mediaKindForMime, mimeAllowed, mimeEssence, profileAccept, } from './catalog.js';
+import { getStructured } from './schemas.js';
+function usesStructuredResponseFormat(structuredId) {
+    if (!structuredId) {
+        return false;
+    }
+    const spec = getStructured(structuredId);
+    return spec.enforced === 'responseFormat' && spec.jsonSchema != null;
+}
+function activePrimaryOutputModes(profile, structuredId) {
+    const modes = [];
+    if (usesStructuredResponseFormat(structuredId)) {
+        modes.push('structured');
     }
-    if (!allowed || allowed.length === 0) {
-        return value;
+    if (profile.type === 'image') {
+        modes.push('image');
     }
-    if (allowed.includes(value)) {
-        return value;
+    if (profile.type === 'speech') {
+        modes.push('speech');
     }
-    return undefined;
+    return modes;
 }
-function resolveSlotOrPin(profileId, label, slotValue, pin, allow) {
-    if (slotValue !== undefined) {
-        const fromSlot = listedValue(allow, slotValue);
-        if (!fromSlot) {
-            throw new TheorumError(`Unknown image ${label} for ${profileId}`);
-        }
-        return fromSlot;
-    }
-    if (pin === undefined) {
-        return undefined;
-    }
-    const fromPin = listedValue(allow, pin);
-    if (!fromPin) {
-        throw new TheorumError(`Unknown image ${label} for ${profileId}`);
+/**
+ * Provider wire formats (JSON schema, image, speech) are mutually exclusive.
+ * Typed profiles make illegal mixes unrepresentable; this remains a safety net
+ * for responseFormat structured on text vs accidental dual modes.
+ */
+function assertOutputMode(profile, structuredId) {
+    const active = activePrimaryOutputModes(profile, structuredId);
+    if (active.length <= 1) {
+        return;
     }
-    return fromPin;
+    throw new TheorumError(`Profile ${profile.id} declares multiple output wire formats (${active.join(', ')}). ` + // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        `Only one of responseFormat JSON schema (outputs.structured with enforced ` + // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        `'responseFormat'), image, or speech may be active.`);
 }
-function assertImageRole(profile) {
-    const pins = profile.outputs.image;
-    if (!pins) {
-        throw new TheorumError(`Profile ${profile.id} requests image output but does not set outputs.image`);
+function assertImagePins(profile) {
+    if (profile.type !== 'image') {
+        throw new TheorumError(`Profile ${profile.id} is not type 'image'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
-    assertExclusiveNativeOutput(profile, 'image');
-    return pins;
+    return profile.image;
+}
+function defaultBinding(profile) {
+    const ids = Object.keys(profile.models);
+    const id = profile.defaultModel ?? (ids.length === 1 ? ids[0] : undefined);
+    return id ? profile.models[id] : undefined;
 }
 function assertSpeechRole(profile) {
-    if (!profile.outputs.speech) {
+    if (profile.type !== 'speech') {
         return;
     }
-    assertExclusiveNativeOutput(profile, 'speech');
-    if (profile.outputs.speech.format === 'mp3' && profile.model.protocol === 'geminiInteractions') {
-        throw new TheorumError(`Profile ${profile.id}: outputs.speech.format 'mp3' requires protocol 'openAi' ` +
+    const format = profile.speech.format;
+    const binding = defaultBinding(profile);
+    if (format && binding && !isSpeechFormatAllowedForProtocol(binding.protocol, format)) {
+        throw new TheorumError(`Profile ${profile.id}: speech.format '${format}' requires protocol 'openAi' ` + // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
             `(geminiInteractions speech returns PCM and emits WAV)`);
     }
 }
-function assertExclusiveNativeOutput(profile, kind) {
-    const other = kind === 'image' ? 'speech' : 'image';
-    if (profile.outputs[other]) {
-        throw new TheorumError(`Profile ${profile.id} cannot mix outputs.${kind} with outputs.${other}`);
-    }
-    if (profile.outputs.structured !== null && profile.outputs.structured !== undefined) {
-        throw new TheorumError(`Profile ${profile.id} cannot mix structured JSON with native ${kind} output`);
-    }
-}
-function resolveImageFormat(profile, _model, slots) {
-    if (!profile.outputs.image) {
+function resolveImageFormat(profile) {
+    if (profile.type !== 'image') {
         return null;
     }
-    const pins = assertImageRole(profile);
-    const aspectRatio = resolveSlotOrPin(profile.id, 'aspect', slots?.aspectRatio, pins.aspectRatio, profile.inputs.slots?.aspectRatio);
-    const size = resolveSlotOrPin(profile.id, 'size', slots?.size, pins.size, profile.inputs.slots?.size);
-    if (!(aspectRatio && size)) {
-        throw new TheorumError(`Unknown image aspect or size for ${profile.id}`);
-    }
+    const pins = assertImagePins(profile);
     return {
         type: 'image',
-        mimeType: pins.mimeType ?? 'image/jpeg',
-        aspectRatio,
-        size,
+        mimeType: pins.mimeType,
+        aspectRatio: pins.aspectRatio,
+        size: pins.size,
+        includeText: pins.includeText === true,
     };
 }
 function assertMediaMime(mime) {
     const kind = mediaKindForMime(mime);
     if (!kind) {
-        throw new TheorumError(`MIME '${mime}' is not a supported media input type`);
+        throw new TheorumError(`MIME '${mime}' is not a supported media input type`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     return kind;
 }
+function profileInputs(profile) {
+    if (profile.type === 'speech' || profile.type === 'live' || profile.type === 'host') {
+        return undefined;
+    }
+    return profile.inputs;
+}
+/**
+ * Normalize accepted attachments into provider parts. Inline blobs and
+ * references share MIME acceptance and kind resolution; references carry the
+ * uri through untouched (no base64, no byte limits — the host owns the upload).
+ */
 function mediaParts(profile, model, blobs, channel) {
-    const accept = channel === 'voice' ? profile.inputs.voice?.accept : profile.inputs.attachments?.accept;
+    const accept = profileAccept(profile, channel);
     if (!accept) {
-        throw new TheorumError(`Profile ${profile.id} does not accept ${channel}`);
+        throw new TheorumError(`Profile ${profile.id} does not accept ${channel}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
-    const maxInputImages = profile.outputs.image?.maxInputImages;
+    const maxInputImages = profile.type === 'image' ? profile.image.maxInputImages : undefined;
     const imageCount = blobs.filter((blob) => mediaKindForMime(blob.mimeType) === 'image').length;
     if (maxInputImages !== undefined && imageCount > maxInputImages) {
-        throw new TheorumError(`At most ${maxInputImages} reference images on ${model}`);
+        throw new TheorumError(`At most ${maxInputImages} reference images on ${model}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     return blobs.map((blob) => {
         const kind = assertMediaMime(blob.mimeType);
         if (!mimeAllowed(accept, blob.mimeType)) {
-            throw new TheorumError(`MIME '${blob.mimeType}' is not accepted on ${profile.id}`);
+            throw new TheorumError(`MIME '${blob.mimeType}' is not accepted on ${profile.id}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
         const essence = mimeEssence(blob.mimeType);
-        return {
-            type: kind,
-            mimeType: essence === 'image/jpg' ? 'image/jpeg' : essence,
-            data: blob.data,
-        };
+        const mimeType = essence === 'image/jpg' ? 'image/jpeg' : essence;
+        if (isTurnMediaRef(blob)) {
+            return { type: kind, mimeType, uri: blob.uri };
+        }
+        return { type: kind, mimeType, data: blob.data };
     });
 }
 function extractTextPart(profile, req) {
     const { text, repair, history } = req.input ?? {};
-    if (profile.inputs.text === false) {
+    if (profile.type === 'speech') {
+        if (!text?.trim()) {
+            throw new TheorumError(`Profile ${profile.id} (speech) requires text input`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        }
+        let promptText = text;
+        if (repair) {
+            promptText = synthesizeRepairPrompt({ profile, repair, history });
+        }
+        return { type: 'text', text: wrapUserData(promptText) };
+    }
+    const inputs = profileInputs(profile);
+    if (inputs?.text === false) {
         if (text) {
-            throw new TheorumError(`Profile ${profile.id} does not accept text input`);
+            throw new TheorumError(`Profile ${profile.id} does not accept text input`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
         return null;
     }
@@ -131,6 +151,13 @@ function extractTextPart(profile, req) {
     return { type: 'text', text: wrapUserData(promptText) };
 }
 function extractMediaParts(profile, model, req) {
+    if (profile.type === 'speech') {
+        const { attachments, voice } = req.input ?? {};
+        if ((attachments?.length ?? 0) + (voice?.length ?? 0) > 0) {
+            throw new TheorumError(`Profile ${profile.id} (speech) does not accept media input`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        }
+        return [];
+    }
     const { attachments, voice } = req.input ?? {};
     const files = attachments ?? [];
     const clips = voice ?? [];
@@ -155,9 +182,4 @@ function resolveInputParts(profile, model, req) {
     parts.push(...extractMediaParts(profile, model, req));
     return parts;
 }
-function assertImageGrounding(profile, model, builtins) {
-    if (profile.outputs.image?.allowsGrounding === false && builtins.length > 0) {
-        throw new TheorumError(`Grounding tools are not valid on ${model}`);
-    }
-}
-export { assertImageGrounding, assertSpeechRole, resolveImageFormat, resolveInputParts };
+export { assertOutputMode, assertSpeechRole, resolveImageFormat, resolveInputParts };

package/esm/src/kernel/registry/profile-outputs.d.ts

@@ -0,0 +1,4 @@
+import type { Profile, ProfileOutputsSpec } from '../types.js';
+/** Turn-based `outputs` pins — absent on `type: 'live'` and `type: 'host'`. */
+declare function profileTurnOutputs(profile: Profile): ProfileOutputsSpec | undefined;
+export { profileTurnOutputs };

package/esm/src/kernel/registry/profile-outputs.js

@@ -0,0 +1,8 @@
+/** Turn-based `outputs` pins — absent on `type: 'live'` and `type: 'host'`. */
+function profileTurnOutputs(profile) {
+    if (profile.type === 'live' || profile.type === 'host') {
+        return undefined;
+    }
+    return profile.outputs;
+}
+export { profileTurnOutputs };

package/esm/src/kernel/registry/profiles.d.ts

@@ -1,23 +1,66 @@
 /**
  * Runtime profile registry for host-owned THEORUM profiles.
  *
- * THEORUM ships profile types and defaults, not application profiles. Host apps
- * register their profiles at process startup or test setup.
+ * THEORUM ships profile types — not application profiles and not invented defaults.
+ * Hosts must pass required fields explicitly (`type`, `models`, …).
  *
  * @module
  */
-import type { Profile } from '../types.js';
-/** Host-authored profile definition, with defaults applied to omitted sections. */
-export type ProfileDefinition = {
+import { type HostGuardrailsSpec, type ProfileGuardrailsSpec } from '../../guardrails/types.js';
+import type { ProfileObservabilitySpec } from '../../observability/types.js';
+import type { HostProfile, HostProfileToolsSpec, ImageProfile, LiveProfile, LiveProfileToolsSpec, ModelBinding, ModelId, Profile, ProfileIdentity, ProfileInputsSpec, ProfileModelFields, ProfileOutputsSpec, ProfileToolsSpec, ProfileTurnBehaviourSpec, SpeechProfile } from '../types.js';
+export type ProfileDefinitionBase = {
     id: Profile['id'];
-    identity?: Partial<Profile['identity']>;
-    model: Partial<Profile['model']> & Pick<Profile['model'], 'allow' | 'config'>;
-    tools?: Partial<Profile['tools']>;
-    inputs?: Partial<Profile['inputs']>;
-    outputs?: Partial<Profile['outputs']>;
-    guardrails?: Partial<Profile['guardrails']>;
+    identity: ProfileIdentity;
+    models: Record<ModelId, ModelBinding>;
+    defaultModel?: ModelId;
+    allowModelSelect?: boolean;
+    maxSteps?: number;
+    key?: ProfileModelFields['key'];
+    outputs?: ProfileOutputsSpec;
+    guardrails?: ProfileGuardrailsSpec;
+    observability?: ProfileObservabilitySpec;
 };
-/** Define a typed profile with stable defaults for optional properties. */
+export type TextProfileDefinition = ProfileDefinitionBase & {
+    type: 'text';
+    tools: ProfileToolsSpec;
+    inputs: ProfileInputsSpec;
+    turnBehaviour?: ProfileTurnBehaviourSpec;
+};
+export type ImageProfileDefinition = ProfileDefinitionBase & {
+    type: 'image';
+    image: NonNullable<ImageProfile['image']>;
+    tools: ProfileToolsSpec;
+    inputs: ProfileInputsSpec;
+    turnBehaviour?: ProfileTurnBehaviourSpec;
+};
+export type SpeechProfileDefinition = ProfileDefinitionBase & {
+    type: 'speech';
+    speech: NonNullable<SpeechProfile['speech']>;
+    turnBehaviour?: ProfileTurnBehaviourSpec;
+};
+export type LiveProfileDefinition = ProfileDefinitionBase & {
+    type: 'live';
+    live: NonNullable<LiveProfile['live']>;
+    tools: LiveProfileToolsSpec;
+    /** Inject gate only — resumption is `live.sessionResumption`. */
+    turnBehaviour?: Pick<ProfileTurnBehaviourSpec, 'allowSteering'>;
+};
+/** Host-driven tool ceiling — no models, identity, inputs, outputs, turnBehaviour, key, or maxSteps. */
+export type HostProfileDefinition = {
+    type: 'host';
+    id: Profile['id'];
+    tools: HostProfileToolsSpec;
+    /** Only the guards that fire on the `invokeTool` path — see {@link HostGuardrailsSpec}. */
+    guardrails?: HostGuardrailsSpec;
+    observability?: ProfileObservabilitySpec;
+};
+/** Host-authored profile definition — discriminated on `type`. No THEORUM defaults. */
+export type ProfileDefinition = TextProfileDefinition | ImageProfileDefinition | SpeechProfileDefinition | LiveProfileDefinition | HostProfileDefinition;
+/** Define a typed profile. Required fields must be set explicitly; optional fields stay optional. */
+declare function defineProfile(input: LiveProfileDefinition): LiveProfile;
+declare function defineProfile(input: HostProfileDefinition): HostProfile;
+declare function defineProfile(input: Exclude<ProfileDefinition, LiveProfileDefinition | HostProfileDefinition>): Exclude<Profile, LiveProfile | HostProfile>;
 declare function defineProfile(input: ProfileDefinition): Profile;
 /** Register one host-owned profile in the process-local registry. */
 declare function registerProfile(profileInput: Profile | ProfileDefinition): void;