@datadog/apps-frontend 0.0.9 → 0.0.10

package/dist/src/_chunks/{chunk-LEEYMNMO.js.map → chunk-E6L6DSL7.js.map}

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../src/embedding/config.ts", "../../../src/embedding/diagnostics.ts", "../../../src/embedding/shared.ts", "../../../src/embedding/contract.ts"],
   "sourcesContent": ["/**\n * Every tunable the embedding protocol uses -- timeouts and the limits that\n * bound peer-influenced state -- together in one place with an obvious name\n * each, instead of scattered as same-looking magic numbers across unrelated\n * files.\n */\n\nexport const PROTOCOL_VERSION = 1;\n\n// --- Timeouts -----------------------------------------------------------\n//\n// Each one is a local decision made independently by whichever side enforces\n// it -- none of these are negotiated with, or need to match, the peer's own\n// value for the same phase.\n\n/** Phase 1: transferring the private control port across the window boundary. */\nexport const BOOTSTRAP_TIMEOUT_MS = 10_000;\n\n/** Phases 2 and 3: protocol compatibility negotiation and bringing up the\n * operational protocol on the transferred port. Each phase receives this\n * full deadline independently. */\nexport const CONNECT_TIMEOUT_MS = 10_000;\n\n/** How long the app waits for the host to answer its claim of a module. */\nexport const CLAIM_TIMEOUT_MS = 5_000;\n\n/** How long a function call is allowed to run (host side) or be waited on\n * (app side). Each side enforces this purely locally -- it is never sent\n * over the wire, and one side never needs to know the other's value: the\n * watchdog that fires first just wins through the normal error path, the\n * same way any other host/app-independent failure already does. */\nexport const FUNCTION_CALL_TIMEOUT_MS = 600_000;\n\n/**\n * Ceiling for a `FunctionField.timeoutMs` override: the largest delay\n * `setTimeout` accepts. Anything above it silently overflows the 32-bit\n * signed timer and fires almost immediately, inverting the longest deadline\n * an author can ask for into the shortest one they could get.\n */\nexport const MAX_TIMER_DELAY_MS = 2_147_483_647;\n\n/** Reject a public timeout override that `setTimeout` cannot represent. */\nexport function assertValidTimerDelay(name: string, timeoutMs: number): void {\n    if (\n        !Number.isFinite(timeoutMs) ||\n        timeoutMs < 0 ||\n        timeoutMs > MAX_TIMER_DELAY_MS\n    ) {\n        throw new RangeError(\n            `${name} must be a finite number between 0 and ${MAX_TIMER_DELAY_MS}.`,\n        );\n    }\n}\n\n/** How often a heartbeat ping is sent, and how long a reply is awaited\n * before it counts as a miss. */\nexport const HEARTBEAT_INTERVAL_MS = 10_000;\nexport const HEARTBEAT_DEADLINE_MS = 5_000;\n\n/** Grace period between posting a close envelope and actually tearing down\n * the transport, so the envelope isn't truncated in flight. */\nexport const CLOSE_DELIVERY_TIMEOUT_MS = 250;\n\n/** Reconnection backoff: starting delay, cap, and how long to keep retrying\n * before giving up on the whole recovery attempt. */\nexport const RECONNECT_RETRY_MS = 1_000;\nexport const RECONNECT_MAX_RETRY_MS = 10_000;\nexport const RECONNECT_GIVE_UP_AFTER_MS = 45_000;\n\n// --- Limits ---------------------------------------------------------------\n//\n// These bound state retained at the request of iframe code, so an\n// adversarial or malformed peer can't grow it without limit. Both peers\n// validate against them independently.\n\nexport const MAX_LIVE_HOST_CLAIMS = 128;\nexport const MAX_CLAIM_ID_LENGTH = 256;\nexport const MAX_CALL_ID_LENGTH = 256;\nexport const MAX_LIVE_HOST_FUNCTION_CALLS = 128;\nexport const MAX_PENDING_ENDPOINT_OPERATIONS = 32;\nexport const MAX_CLAIM_FIELDS = 128;\nexport const MAX_CLAIM_FIELD_NAME_LENGTH = 256;\n", "/**\n * Console diagnostics for every embedding outcome that is not\n * starting -> connecting -> connected.\n *\n * Debugging an embedding failure means reasoning about two documents that each\n * see half of the connection: the Datadog page owns the host listener, the app\n * iframe owns the connection handle, and neither observes why the other gave\n * up. Every failure, rejection, timeout, and lost connection therefore reports\n * itself locally, naming the side that produced it and carrying the detail the\n * wire deliberately does not: raw causes, validation issues, claim and call\n * identifiers, attempt counts, and the deadline that expired.\n *\n * This module never throws. It runs on paths that are already failing, in\n * browsers we do not control, so a missing or hostile `console` must not\n * replace the failure being reported.\n */\n\nimport type { AnyError } from './types';\n\nconst PREFIX = '[Datadog Apps embedding]';\n\n/** How deep an `Error.cause` chain is described before it is truncated. */\nconst MAX_CAUSE_DEPTH = 3;\n\n/** Which peer produced a log line; both peers run this code. */\nexport type DiagnosticSide = 'app' | 'host';\n\nexport type DiagnosticDetail = Readonly<Record<string, unknown>>;\n\n/**\n * Renders an arbitrary thrown value as inspectable data. Errors lose their\n * `name`, `message`, `stack`, and `cause` when a console is handed a bare\n * `Error` inside an object in some environments, so those are spread out\n * explicitly; anything else is passed through for the console to format.\n */\nexport function describeCause(cause: unknown, depth = 0): unknown {\n    if (!(cause instanceof Error)) {\n        return cause;\n    }\n    // A peer-influenced Error may have hostile name/message/stack/cause\n    // accessors; this module's \"never throws\" guarantee must hold even then.\n    try {\n        const described: Record<string, unknown> = {\n            name: cause.name,\n            message: cause.message,\n        };\n        if (typeof cause.stack === 'string') {\n            described.stack = cause.stack;\n        }\n        if (cause.cause !== undefined) {\n            described.cause =\n                depth < MAX_CAUSE_DEPTH\n                    ? describeCause(cause.cause, depth + 1)\n                    : '(cause chain truncated)';\n        }\n        return described;\n    } catch {\n        return '(cause could not be described)';\n    }\n}\n\n/**\n * Renders a wire error for logging. Every code carries structured-clone-safe\n * data already, except the local-only `cause` of `TRANSPORT_FAILED`, which is\n * where the actual explanation usually lives.\n */\nexport function describeError(error: AnyError): DiagnosticDetail {\n    return 'cause' in error\n        ? { ...error, cause: describeCause(error.cause) }\n        : error;\n}\n\nfunction log(\n    level: 'warn' | 'error',\n    event: string,\n    detail: DiagnosticDetail,\n): void {\n    try {\n        globalThis.console?.[level](`${PREFIX} ${event}`, detail);\n    } catch {\n        // A console that cannot be used is not a reason to lose the outcome\n        // this call was reporting.\n    }\n}\n\n/** A failure the connection expects to recover from, or a degraded outcome. */\nexport function logWarning(event: string, detail: DiagnosticDetail = {}): void {\n    log('warn', event, detail);\n}\n\n/** A failure a consumer observes: terminal, unrecoverable, or data-losing. */\nexport function logFailure(event: string, detail: DiagnosticDetail = {}): void {\n    log('error', event, detail);\n}\n", "import { describeCause, logFailure } from './diagnostics';\nimport type { Result } from './types';\n\nlet nextId = 0;\n\n/**\n * The counter prevents local reuse if randomness repeats; the random segment\n * makes heartbeat nonces difficult for the peer to predict.\n */\nexport function createId(prefix: string): string {\n    nextId += 1;\n    return `${prefix}:${randomSegment()}:${nextId.toString(36)}`;\n}\n\nfunction randomSegment(): string {\n    const bytes = new Uint8Array(8);\n    globalThis.crypto.getRandomValues(bytes);\n    let segment = '';\n    for (const byte of bytes) {\n        segment += byte.toString(16).padStart(2, '0');\n    }\n    return segment;\n}\n\nexport function success<TValue>(value: TValue): Result<TValue, never> {\n    return { ok: true, value };\n}\n\nexport function err<TError>(value: TError): Result<never, TError> {\n    return { ok: false, error: value };\n}\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n    return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * True when `value` is a well-formed identifier: a non-empty string. Bounds\n * its length to at most `limit` characters only when a limit is supplied.\n */\nexport function isValidIdentifier(\n    value: unknown,\n    limit?: number,\n): value is string {\n    return (\n        typeof value === 'string' &&\n        value.length > 0 &&\n        (limit === undefined || value.length <= limit)\n    );\n}\n\n/**\n * Runs a cleanup action that must not throw into its caller. Teardown runs on\n * paths that are already failing, so a secondary failure is reported and\n * swallowed instead of replacing the outcome the caller is about to return.\n */\nexport function teardown(description: string, action: () => void): void {\n    try {\n        action();\n    } catch (error) {\n        logFailure('a teardown step failed', {\n            description,\n            cause: describeCause(error),\n        });\n    }\n}\n\n/**\n * Calls every listener, isolating exceptions so one listener throwing doesn't\n * stop the rest from being notified or propagate into the caller that\n * triggered the notification.\n */\nexport function notifyListeners<TArgs extends readonly unknown[] = []>(\n    listeners: Iterable<(...args: TArgs) => void>,\n    ...args: TArgs\n): void {\n    for (const listener of [...listeners]) {\n        try {\n            listener(...args);\n        } catch (error) {\n            // Rethrown out of band, where the stack no longer shows that\n            // embedding was notifying a listener.\n            logFailure('an embedding listener threw', {\n                cause: describeCause(error),\n            });\n            globalThis.queueMicrotask(() => {\n                throw error;\n            });\n        }\n    }\n}\n", "import {\n    MAX_CLAIM_FIELDS,\n    MAX_CLAIM_FIELD_NAME_LENGTH,\n    MAX_TIMER_DELAY_MS,\n} from './config';\nimport { isRecord, isValidIdentifier } from './shared';\nimport type {\n    AnyContract,\n    AnyField,\n    AnyFunctionField,\n    AnySchema,\n    Contract,\n    ContractVersion,\n    FunctionField,\n    HostFunction,\n    HostModule,\n    LiveValue,\n    ValidationOnlySchema,\n    ValueField,\n} from './types';\n\n/**\n * A field name must be a valid own-property identifier the wire protocol\n * will actually carry: excludes \"__proto__\" and other names that a plain\n * object assignment would resolve against the prototype chain instead of\n * creating an own property. Exported so every place a contract-shaped field\n * name is declared (e.g. an older version's `extraInputs`) enforces the same\n * shape, not just `defineContract` itself.\n */\nexport const VALID_FIELD_NAME: RegExp = /^[A-Za-z][A-Za-z0-9_]*$/;\n\n/**\n * Every module this package has minted. Backs the runtime half of\n * `HostModule`'s brand, so a structurally-identical object built elsewhere is\n * rejected at `listen()` even where types were bypassed.\n */\nconst mintedHostModules = new WeakSet<object>();\n\n/**\n * The only way a `HostModule` comes into existence. Kept here, beside the\n * validation it has to satisfy, and deliberately not re-exported from\n * `@datadog/apps-frontend/embedding/internal` -- a host reaches modules only\n * as the output of providing an inputs definition, never by naming a version\n * and building one itself.\n */\nexport function createHostModule(\n    contract: AnyContract,\n    implementation: Readonly<Record<string, LiveValue<unknown> | HostFunction>>,\n    signal?: AbortSignal,\n): HostModule {\n    // A null-prototype snapshot means a wire-supplied field name (e.g.\n    // \"__proto__\" or \"constructor\") can never resolve to an inherited\n    // Object.prototype member when this dict is later indexed by that name.\n    const snapshot: Record<string, LiveValue<unknown> | HostFunction> =\n        Object.create(null);\n    for (const [name, provider] of Object.entries(implementation)) {\n        snapshot[name] = provider;\n    }\n    Object.freeze(snapshot);\n    const module = Object.freeze(\n        signal === undefined\n            ? { contract, implementation: snapshot }\n            : { contract, implementation: snapshot, signal },\n    ) as unknown as HostModule;\n    mintedHostModules.add(module);\n    return module;\n}\n\nfunction isSchemaShape(value: unknown): value is AnySchema {\n    if (\n        !(\n            (typeof value === 'object' && value !== null) ||\n            typeof value === 'function'\n        )\n    ) {\n        return false;\n    }\n    const standard = (value as AnySchema)['~standard'];\n    return (\n        isRecord(standard) &&\n        standard.version === 1 &&\n        typeof standard.validate === 'function'\n    );\n}\n\n/**\n * True when `field` has the generic shape of a read-only value field.\n * Ignores identifier-name rules and implementation matching, which are\n * caller-specific (e.g. host modules also validate against a provider).\n */\nexport function isValueFieldShape(\n    field: unknown,\n): field is ValueField<AnySchema> {\n    return (\n        isRecord(field) && field.kind === 'value' && isSchemaShape(field.schema)\n    );\n}\n\n/**\n * True when `field` has the generic shape of a callable function field.\n * Ignores identifier-name rules and implementation matching, which are\n * caller-specific (e.g. host modules also validate against a provider).\n */\nexport function isFunctionFieldShape(\n    field: unknown,\n): field is AnyFunctionField {\n    return (\n        isRecord(field) &&\n        field.kind === 'function' &&\n        isRecord(field.inputs) &&\n        Object.entries(field.inputs).every(\n            ([name, schema]) => name.length > 0 && isSchemaShape(schema),\n        ) &&\n        isSchemaShape(field.result)\n    );\n}\n\n/** True when `field` has the generic shape of any well-formed contract field. */\nexport function isAnyFieldShape(field: unknown): field is AnyField {\n    return isValueFieldShape(field) || isFunctionFieldShape(field);\n}\n\n/**\n * True when a function field's optional `timeoutMs` is a deadline a call could\n * actually meet -- see `FunctionField.timeoutMs` for why each end is not.\n *\n * Deliberately separate from `isFunctionFieldShape`: this is about a value being\n * sensible, not about the field being a function, so folding it in would make an\n * out-of-range deadline report as a malformed shape or a mismatched provider.\n */\nexport function hasUsableFunctionTimeout(field: AnyField): boolean {\n    return (\n        field.kind !== 'function' ||\n        field.timeoutMs === undefined ||\n        (typeof field.timeoutMs === 'number' &&\n            Number.isFinite(field.timeoutMs) &&\n            field.timeoutMs > 0 &&\n            field.timeoutMs <= MAX_TIMER_DELAY_MS)\n    );\n}\n\ninterface ReadOnlyValueBuilder {\n    readOnly<TSchema extends AnySchema>(\n        schema: ValidationOnlySchema<TSchema>,\n    ): ValueField<TSchema>;\n}\n\ninterface ReadOnlyFunctionBuilder {\n    readOnly<\n        const TInputs extends Readonly<Record<string, AnySchema>>,\n        TResult extends AnySchema,\n    >(\n        definition: Readonly<{\n            inputs: {\n                readonly [TName in keyof TInputs]: ValidationOnlySchema<\n                    TInputs[TName]\n                >;\n            };\n            result: ValidationOnlySchema<TResult>;\n            /**\n             * Optional per-function override of `FUNCTION_CALL_TIMEOUT_MS`.\n             * See `FunctionField.timeoutMs`.\n             */\n            timeoutMs?: number;\n        }>,\n    ): FunctionField<TInputs, TResult>;\n}\n\n/**\n * Builds a value field for any embedding contract. `readOnly` is the only\n * builder today because no transport exists for an app to write a value\n * back to the host; the name leaves room for a future writable builder\n * without implying one exists yet.\n */\nexport const value: ReadOnlyValueBuilder = /* @__PURE__ */ Object.freeze({\n    readOnly<TSchema extends AnySchema>(\n        schema: ValidationOnlySchema<TSchema>,\n    ): ValueField<TSchema> {\n        return Object.freeze({ kind: 'value', schema });\n    },\n});\n\n/** Builds a callable function field for any embedding contract. */\nexport const fn: ReadOnlyFunctionBuilder = /* @__PURE__ */ Object.freeze({\n    readOnly<\n        const TInputs extends Readonly<Record<string, AnySchema>>,\n        TResult extends AnySchema,\n    >({\n        inputs,\n        result,\n        timeoutMs,\n    }: Readonly<{\n        inputs: {\n            readonly [TName in keyof TInputs]: ValidationOnlySchema<\n                TInputs[TName]\n            >;\n        };\n        result: ValidationOnlySchema<TResult>;\n        timeoutMs?: number;\n    }>): FunctionField<TInputs, TResult> {\n        // Omitted entirely rather than stored as an explicit `undefined`, so\n        // `'timeoutMs' in field` answers whether an override was declared.\n        return Object.freeze(\n            timeoutMs === undefined\n                ? { kind: 'function', inputs, result }\n                : { kind: 'function', inputs, result, timeoutMs },\n        );\n    },\n});\n\ntype ValidationOnlyField<TField extends AnyField> =\n    TField extends Readonly<{\n        kind: 'value';\n        schema: infer TSchema extends AnySchema;\n    }>\n        ? TField & Readonly<{ schema: ValidationOnlySchema<TSchema> }>\n        : TField extends Readonly<{\n                kind: 'function';\n                inputs: infer TInputs extends Readonly<\n                    Record<string, AnySchema>\n                >;\n                result: infer TResult extends AnySchema;\n            }>\n          ? TField &\n                Readonly<{\n                    inputs: {\n                        readonly [TName in keyof TInputs]: ValidationOnlySchema<\n                            TInputs[TName]\n                        >;\n                    };\n                    result: ValidationOnlySchema<TResult>;\n                }>\n          : never;\n\ntype ValidationOnlyFields<TFields extends Record<string, AnyField>> = {\n    readonly [TName in keyof TFields]: ValidationOnlyField<TFields[TName]>;\n};\n\n/**\n * Assembles and validates a well-formed `Contract`: the one place any\n * claim-defining module builds an identifier, version, and fields into the\n * shape the embedding protocol requires. Field-shape correctness reuses\n * `isAnyFieldShape` so there is a single source of truth for what a\n * contract field looks like, shared with the host-registration gate above.\n */\nexport function defineContract<\n    const TIdentifier extends string,\n    const TVersion extends ContractVersion,\n    const TFields extends Record<string, AnyField>,\n>(\n    definition: Contract<TFields> &\n        Readonly<{\n            identifier: TIdentifier;\n            version: TVersion;\n            fields: ValidationOnlyFields<TFields>;\n        }>,\n): Contract<TFields> &\n    Readonly<{ identifier: TIdentifier; version: TVersion }> {\n    if (!isValidIdentifier(definition.identifier)) {\n        throw new Error(\n            `Invalid embedding contract identifier \"${String(definition.identifier)}\".`,\n        );\n    }\n    if (!Number.isSafeInteger(definition.version) || definition.version < 1) {\n        throw new Error(\n            `Embedding contract \"${definition.identifier}\" must have a positive integer version.`,\n        );\n    }\n\n    const entries = Object.entries(definition.fields);\n    if (entries.length === 0 || entries.length > MAX_CLAIM_FIELDS) {\n        throw new Error(\n            `Embedding contract \"${definition.identifier}\" must define between 1 and ${MAX_CLAIM_FIELDS} fields.`,\n        );\n    }\n    for (const [name, field] of entries) {\n        if (\n            !VALID_FIELD_NAME.test(name) ||\n            name.length > MAX_CLAIM_FIELD_NAME_LENGTH ||\n            !isAnyFieldShape(field)\n        ) {\n            throw new Error(\n                `Embedding contract field \"${definition.identifier}.${name}\" must be a named read-only value or function whose schemas implement Standard Schema V1.`,\n            );\n        }\n        if (!hasUsableFunctionTimeout(field)) {\n            throw new Error(\n                `Embedding contract field \"${definition.identifier}.${name}\" declares a timeoutMs no call could meet. It must be greater than 0 and at most ${MAX_TIMER_DELAY_MS}.`,\n            );\n        }\n    }\n\n    return Object.freeze({\n        identifier: definition.identifier,\n        version: definition.version,\n        fields: Object.freeze(\n            Object.fromEntries(\n                entries.map(([name, field]) => [\n                    name,\n                    field.kind === 'value'\n                        ? Object.freeze({ ...field, schema: field.schema })\n                        : Object.freeze({\n                              ...field,\n                              inputs: Object.freeze({ ...field.inputs }),\n                              result: field.result,\n                          }),\n                ]),\n            ),\n        ) as unknown as TFields,\n    });\n}\n\n/**\n * The host-side registration gate. Runs when a host registers its modules, so\n * a contract that does not match its implementation fails loudly at `listen()`\n * instead of as a confusing claim failure later.\n */\nexport function assertHostModule(module: HostModule): void {\n    if (!isRecord(module) || !mintedHostModules.has(module)) {\n        throw new Error(\n            'A host module must come from its module provider -- the host-side helper that serves every contract version its definition still converts to.',\n        );\n    }\n    if (\n        !isRecord(module.contract) ||\n        !isValidIdentifier(module.contract.identifier) ||\n        typeof module.contract.version !== 'number' ||\n        !Number.isSafeInteger(module.contract.version) ||\n        module.contract.version < 1 ||\n        !isRecord(module.contract.fields) ||\n        Object.keys(module.contract.fields).length === 0 ||\n        !isRecord(module.implementation) ||\n        (module.signal !== undefined &&\n            (typeof module.signal.aborted !== 'boolean' ||\n                typeof module.signal.addEventListener !== 'function' ||\n                typeof module.signal.removeEventListener !== 'function'))\n    ) {\n        throw new Error('The host module has an invalid contract.');\n    }\n\n    for (const [name, field] of Object.entries(module.contract.fields)) {\n        const provider = Object.hasOwn(module.implementation, name)\n            ? module.implementation[name]\n            : undefined;\n        if (\n            !VALID_FIELD_NAME.test(name) ||\n            name.length > MAX_CLAIM_FIELD_NAME_LENGTH\n        ) {\n            throw new Error(\n                `A host module field name \"${name}\" is not a valid claim field name.`,\n            );\n        }\n        const isValue =\n            isValueFieldShape(field) &&\n            isRecord(provider) &&\n            typeof provider.get === 'function' &&\n            typeof provider.subscribe === 'function';\n        const isFunction =\n            isFunctionFieldShape(field) &&\n            isRecord(provider) &&\n            typeof provider.invoke === 'function';\n        if (!isValue && !isFunction) {\n            throw new Error(\n                `The implementation of \"${module.contract.identifier}.${name}\" does not match its field contract.`,\n            );\n        }\n    }\n}\n\n/**\n * Validates a whole registration: every module well-formed and no duplicate\n * `(identifier, version)`. Returns the failure rather than throwing so a\n * caller can report it over the connection.\n */\nexport function invalidHostModule(\n    modules: readonly HostModule[],\n): Error | undefined {\n    try {\n        const versions = new Set<string>();\n        for (const module of modules) {\n            assertHostModule(module);\n            const key = JSON.stringify([\n                module.contract.identifier,\n                module.contract.version,\n            ]);\n            if (versions.has(key)) {\n                throw new Error(\n                    `The host registered \"${module.contract.identifier}\" v${module.contract.version} more than once.`,\n                );\n            }\n            versions.add(key);\n        }\n        return undefined;\n    } catch (error) {\n        return error instanceof Error\n            ? error\n            : new Error('The host module is invalid.', { cause: error });\n    }\n}\n"],
-  "mappings": "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",
+  "mappings": "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",
   "names": ["assertValidTimerDelay", "name", "timeoutMs", "HEARTBEAT_INTERVAL_MS", "HEARTBEAT_DEADLINE_MS", "CLOSE_DELIVERY_TIMEOUT_MS", "RECONNECT_RETRY_MS", "RECONNECT_MAX_RETRY_MS", "RECONNECT_GIVE_UP_AFTER_MS", "MAX_LIVE_HOST_CLAIMS", "MAX_CLAIM_ID_LENGTH", "MAX_CALL_ID_LENGTH", "MAX_LIVE_HOST_FUNCTION_CALLS", "MAX_PENDING_ENDPOINT_OPERATIONS", "MAX_CLAIM_FIELDS", "MAX_CLAIM_FIELD_NAME_LENGTH", "PREFIX", "describeCause", "cause", "depth", "described", "describeError", "error", "log", "level", "event", "detail", "PREFIX", "logWarning", "logFailure", "nextId", "createId", "prefix", "randomSegment", "bytes", "segment", "byte", "success", "value", "err", "isRecord", "isValidIdentifier", "limit", "teardown", "description", "action", "error", "logFailure", "describeCause", "notifyListeners", "listeners", "args", "listener", "VALID_FIELD_NAME", "mintedHostModules", "createHostModule", "contract", "implementation", "signal", "snapshot", "name", "provider", "module", "isSchemaShape", "value", "standard", "isRecord", "isValueFieldShape", "field", "isFunctionFieldShape", "schema", "isAnyFieldShape", "hasUsableFunctionTimeout", "fn", "inputs", "result", "timeoutMs", "defineContract", "definition", "isValidIdentifier", "entries", "MAX_CLAIM_FIELDS", "MAX_CLAIM_FIELD_NAME_LENGTH"]
 }

package/dist/src/_chunks/chunk-OF23NNWB.js

@@ -0,0 +1,34 @@
+/* Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+import {
+  d as i
+} from "./chunk-VSZMABRM.js";
+import {
+  g as n
+} from "./chunk-BWBMAWDD.js";
+
+// src/inputs/react/use-package-datadog-app-input.ts
+import { useSyncExternalStore as a } from "react";
+function o(t) {
+  let p = i();
+  n(t);
+  let e = p.getClaim(t.latest);
+  return a(
+    e.subscribe,
+    e.getSnapshot,
+    e.getSnapshot
+  );
+}
+
+// src/inputs/react/use-datadog-app-input.ts
+function d(t) {
+  return o(t);
+}
+
+export {
+  d as a
+};
+//# sourceMappingURL=chunk-OF23NNWB.js.map

package/dist/src/_chunks/{chunk-XSHCFEOH.js.map → chunk-OF23NNWB.js.map}

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../src/inputs/react/use-package-datadog-app-input.ts", "../../../src/inputs/react/use-datadog-app-input.ts"],
   "sourcesContent": ["import { useSyncExternalStore } from 'react';\n\nimport { useAppEmbedding } from '../../embedding/react/context';\nimport type { ClaimState } from '../../embedding/types';\nimport type { AnyPublishedDatadogAppInput } from '../published-definition';\nimport { assertPublishedDatadogAppInputsDefinition } from '../published-definition';\n\n/** Claims a package-owned definition that is absent from the public schema barrel. */\nexport function usePackageDatadogAppInput<\n    TDefinition extends AnyPublishedDatadogAppInput,\n>(definition: TDefinition): ClaimState<TDefinition['latest']> {\n    const embedding = useAppEmbedding();\n    assertPublishedDatadogAppInputsDefinition(definition);\n    const store = embedding.getClaim<TDefinition['latest']>(definition.latest);\n    return useSyncExternalStore(\n        store.subscribe,\n        store.getSnapshot,\n        store.getSnapshot,\n    );\n}\n", "import type { ClaimState } from '../../embedding/types';\nimport type { DatadogAppInputDefinition } from '../schemas/index';\n\nimport { usePackageDatadogAppInput } from './use-package-datadog-app-input';\n\n/**\n * What {@link useDatadogAppInput} gives back for one input: `pending` while the\n * connection or claim is in flight, `ready` with validated `fields`, `unavailable`\n * when this host does not provide the input, or `failed` with an actionable\n * `error`. `fields` exists only on `ready`, so stale values can never be read as\n * live.\n *\n * Named in terms of the input rather than the contract behind it -- which\n * version is being served is not a caller's concern.\n */\nexport type DatadogAppInputState<\n    TDefinition extends DatadogAppInputDefinition,\n> = ClaimState<TDefinition['latest']>;\n\n/**\n * A type that refuses to match while saying why.\n *\n * A compiler error is the one piece of documentation a caller cannot skip, so\n * rejections here resolve to a sentence rather than to a bare `never` -- the\n * message becomes the error text, at the call site, in the editor.\n */\ntype Rejected<TMessage extends string> = Readonly<{\n    __datadogAppInputsError: TMessage;\n}>;\n\ntype PublishedDefinitionFor<TDefinition extends DatadogAppInputDefinition> =\n    Extract<\n        DatadogAppInputDefinition,\n        Readonly<{ identifier: TDefinition['identifier'] }>\n    >;\n\ntype NoExtraFields<TDefinition extends DatadogAppInputDefinition> =\n    Exclude<\n        keyof TDefinition['latest']['fields'],\n        keyof PublishedDefinitionFor<TDefinition>['latest']['fields']\n    > extends never\n        ? unknown\n        : Rejected<'This definition has fields the published one does not. Pass a definition exported from @datadog/apps-frontend/inputs/schema, unmodified.'>;\n\n/**\n * Claims one Datadog App input and tracks its state across renders. Call it\n * below {@link DatadogAppProvider}.\n *\n * Pass a definition exported from `@datadog/apps-frontend/inputs/schema` --\n * {@link datadogTheme} is one. Hovering a definition shows the surfaces it is\n * offered on; the returned {@link ClaimState} says whether its values are usable\n * yet, and carries `fields` only while they are.\n *\n * Versions are not a caller's concern: this claims whichever version the\n * installed copy of the package treats as latest. An older copy asks for an\n * older version and keeps working for as long as the host still converts to it.\n * Past that the claim fails with `APP_MAJOR_TOO_OLD` -- update this package and\n * re-upload the app -- rather than silently degrading.\n *\n * @param definition An input definition from `@datadog/apps-frontend/inputs/schema`.\n * @returns The claim's current state: `pending`, `ready` (with `fields`),\n * `unavailable` when this host does not provide the input, or `failed` with an\n * actionable `error`.\n */\nexport function useDatadogAppInput<\n    const TDefinition extends DatadogAppInputDefinition,\n>(\n    definition: TDefinition & NoExtraFields<TDefinition>,\n): DatadogAppInputState<TDefinition> {\n    return usePackageDatadogAppInput<TDefinition>(definition);\n}\n"],
-  "mappings": "gFAAA,OAAS,wBAAAA,MAA4B,QAQ9B,SAASC,EAEdC,EAA4D,CAC1D,IAAMC,EAAYC,EAAgB,EAClCC,EAA0CH,CAAU,EACpD,IAAMI,EAAQH,EAAU,SAAgCD,EAAW,MAAM,EACzE,OAAOK,EACHD,EAAM,UACNA,EAAM,YACNA,EAAM,WACV,CACJ,CC6CO,SAASE,EAGZC,EACiC,CACjC,OAAOC,EAAuCD,CAAU,CAC5D",
+  "mappings": ";;;;;;;;AAAA,SAAS,wBAAAA,SAA4B;AAQ9B,SAASC,EAEdC,GAA4D;AAC1D,MAAMC,IAAYC,EAAgB;AAClC,EAAAC,EAA0CH,CAAU;AACpD,MAAMI,IAAQH,EAAU,SAAgCD,EAAW,MAAM;AACzE,SAAOK;AAAA,IACHD,EAAM;AAAA,IACNA,EAAM;AAAA,IACNA,EAAM;AAAA,EACV;AACJ;;;AC6CO,SAASE,EAGZC,GACiC;AACjC,SAAOC,EAAuCD,CAAU;AAC5D;",
   "names": ["useSyncExternalStore", "usePackageDatadogAppInput", "definition", "embedding", "useAppEmbedding", "assertPublishedDatadogAppInputsDefinition", "store", "useSyncExternalStore", "useDatadogAppInput", "definition", "usePackageDatadogAppInput"]
 }