agentera 3.0.0-dev.8 → 3.0.0-dev.81

package/dist/registries/glossaryProfileFullContract.js

@@ -0,0 +1,24 @@
+import { loadYamlMappingFile } from "../core/yaml.js";
+import { glossaryEntryAuthorityPath } from "./glossaryEntryContract.js";
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function exactPositiveLimit(value, expected) {
+    if (!Number.isSafeInteger(value) || value !== expected) {
+        throw new TypeError("personal glossary Profile Full contract is unavailable");
+    }
+    return value;
+}
+/** Load the bounded Profile Full integration settings from the glossary authority. */
+export function personalGlossaryProfileFullContract(pathname = glossaryEntryAuthorityPath()) {
+    const authority = loadYamlMappingFile(pathname);
+    const profileFull = mapping(mapping(authority.personal_mining_authority)?.profile_full);
+    const existingGeneration = mapping(profileFull?.existing_generation);
+    const review = mapping(profileFull?.review);
+    return {
+        candidateListLimit: exactPositiveLimit(existingGeneration?.list_limit, 20),
+        questionReviewMaximum: exactPositiveLimit(review?.question_channel_maximum, 3),
+    };
+}

package/dist/registries/glossaryReviewRecordsAuthority.js

@@ -0,0 +1,426 @@
+import { createHash, verify as verifySignature } from "node:crypto";
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function sameStrings(actual, expected) {
+    return JSON.stringify(strings(actual)) === JSON.stringify(expected);
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function sha256Utf8(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+const REVIEW_RECEIPT_FIELDS = [
+    "schema_version",
+    "issuer",
+    "subject",
+    "trusted_channel",
+    "review_id",
+    "candidate_id",
+    "candidate_revision",
+    "candidate_projection_sha256",
+    "semantic_fingerprint",
+    "generation",
+    "policy_version",
+    "disposition",
+    "corrected_meaning",
+    "corrected_scope",
+    "disposed_at",
+    "expires_at",
+    "nonce",
+    "signature",
+];
+const REVIEW_RECEIPT_SIGNED_FIELDS = REVIEW_RECEIPT_FIELDS.filter((field) => field !== "signature");
+export const PERSONAL_REVIEW_DISPOSITIONS = ["accept", "correct", "reject", "defer"];
+function receiptField(receipt, field) {
+    const value = receipt[field];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new TypeError(`review approval receipt field ${field} must be a non-empty string`);
+    }
+    return value;
+}
+function nullableReceiptField(receipt, field) {
+    const value = receipt[field];
+    if (value !== null && typeof value !== "string") {
+        throw new TypeError(`review approval receipt field ${field} must be a string or null`);
+    }
+    return value;
+}
+function signedReviewReceiptPayload(receipt) {
+    return JSON.stringify(Object.fromEntries(REVIEW_RECEIPT_SIGNED_FIELDS.map((field) => [
+        field,
+        ["corrected_meaning", "corrected_scope"].includes(field)
+            ? nullableReceiptField(receipt, field)
+            : receiptField(receipt, field),
+    ])));
+}
+export function personalReviewApprovalReceiptDigest(receipt) {
+    const payload = signedReviewReceiptPayload(receipt);
+    return sha256Utf8(JSON.stringify({
+        signed: JSON.parse(payload),
+        signature: receiptField(receipt, "signature"),
+    }));
+}
+export function personalReviewApprovalReplayStatus(receipt, consumedReceiptDigests = new Map(), replayNonceKey) {
+    const nonce = receiptField(receipt, "nonce");
+    const key = replayNonceKey ?? nonce;
+    if (typeof key !== "string" || key.length === 0) {
+        throw new TypeError("review approval replay nonce key must be a non-empty string");
+    }
+    const consumedDigest = consumedReceiptDigests.get(key);
+    if (!consumedDigest)
+        return "new";
+    return consumedDigest === personalReviewApprovalReceiptDigest(receipt)
+        ? "exact_replay"
+        : "conflicting_replay";
+}
+export function validatePersonalReviewApprovalReceipt(receipt, expected) {
+    const errors = [];
+    const extraFields = Object.keys(receipt).filter((field) => !REVIEW_RECEIPT_FIELDS.includes(field));
+    if (extraFields.length > 0)
+        errors.push(`review approval receipt has forbidden fields: ${extraFields.join(", ")}`);
+    let payload = "";
+    let signature = "";
+    try {
+        payload = signedReviewReceiptPayload(receipt);
+        signature = receiptField(receipt, "signature");
+    }
+    catch (error) {
+        errors.push(error.message);
+    }
+    if (receipt.schema_version !== "agentera.personalGlossaryReviewApproval.v1") {
+        errors.push("review approval receipt schema_version is invalid");
+    }
+    if (receipt.issuer !== "agentera-local-host") {
+        errors.push("review approval receipt issuer is not trusted");
+    }
+    if (receipt.subject !== expected.currentUserSubject ||
+        ["agent", "model", "imported_record", "generic_consent"].includes(String(receipt.subject))) {
+        errors.push("review approval receipt subject is not the trusted current user");
+    }
+    if (receipt.trusted_channel !== "agentera-local-host-ipc") {
+        errors.push("review approval receipt trusted channel is invalid");
+    }
+    if (receipt.review_id !== expected.reviewId) {
+        errors.push("review approval receipt review binding is invalid");
+    }
+    if (receipt.candidate_id !== expected.candidateId) {
+        errors.push("review approval receipt candidate binding is invalid");
+    }
+    if (receipt.candidate_revision !== expected.candidateRevision) {
+        errors.push("review approval receipt revision binding is invalid");
+    }
+    if (receipt.candidate_projection_sha256 !== expected.candidateProjectionSha256) {
+        errors.push("review approval receipt projection binding is invalid");
+    }
+    if (receipt.semantic_fingerprint !== expected.semanticFingerprint) {
+        errors.push("review approval receipt semantic fingerprint binding is invalid");
+    }
+    if (receipt.generation !== expected.generation) {
+        errors.push("review approval receipt generation binding is invalid");
+    }
+    if (receipt.policy_version !== expected.policyVersion) {
+        errors.push("review approval receipt policy binding is invalid");
+    }
+    if (!PERSONAL_REVIEW_DISPOSITIONS.includes(receipt.disposition)) {
+        errors.push("review approval receipt disposition is invalid");
+    }
+    if (receipt.disposition === "correct") {
+        if (typeof receipt.corrected_meaning !== "string" ||
+            receipt.corrected_meaning.trim().length === 0 ||
+            Buffer.byteLength(receipt.corrected_meaning, "utf8") > 4_096) {
+            errors.push("review approval receipt corrected_meaning is invalid");
+        }
+        if (receipt.corrected_scope !== "personal") {
+            errors.push("review approval receipt corrected_scope is invalid");
+        }
+    }
+    else if (receipt.corrected_meaning !== null || receipt.corrected_scope !== null) {
+        errors.push("review approval receipt correction fields are invalid");
+    }
+    const disposedAt = Date.parse(String(receipt.disposed_at));
+    const expiresAt = Date.parse(String(receipt.expires_at));
+    const now = expected.now.getTime();
+    if (!Number.isFinite(disposedAt) || !Number.isFinite(expiresAt)) {
+        errors.push("review approval receipt freshness timestamps are invalid");
+    }
+    else {
+        if (disposedAt > now)
+            errors.push("review approval receipt disposed_at is in the future");
+        if (now - disposedAt > 300_000)
+            errors.push("review approval receipt is stale");
+        if (expiresAt <= now || expiresAt <= disposedAt) {
+            errors.push("review approval receipt expires_at is not current");
+        }
+        if (expiresAt - disposedAt > 300_000) {
+            errors.push("review approval receipt freshness window is too long");
+        }
+    }
+    if (!/^[A-Za-z0-9_-]+$/.test(signature)) {
+        errors.push("review approval receipt signature encoding is invalid");
+    }
+    else if (payload) {
+        try {
+            if (!verifySignature(null, Buffer.from(payload, "utf8"), expected.trustedHostPublicKey, Buffer.from(signature, "base64url"))) {
+                errors.push("review approval receipt signature is not from the trusted host");
+            }
+        }
+        catch {
+            errors.push("review approval receipt signature verification failed");
+        }
+    }
+    try {
+        if (personalReviewApprovalReplayStatus(receipt, expected.consumedReceiptDigests, expected.replayNonceKey) === "conflicting_replay") {
+            errors.push("review approval receipt nonce was replayed with changed content");
+        }
+    }
+    catch (error) {
+        errors.push(error.message);
+    }
+    return errors;
+}
+export function personalReviewDispositionLifecycle(disposition) {
+    if (["accept", "correct", "reject"].includes(disposition))
+        return "terminal";
+    if (disposition === "defer")
+        return "pending";
+    throw new TypeError("review disposition is invalid");
+}
+export function projectPersonalReviewRetention(disposition, ageDays, purgeRequested = false) {
+    if (!Number.isFinite(ageDays) || ageDays < 0)
+        throw new TypeError("review age must be non-negative");
+    if (purgeRequested)
+        return { excerpt: "purged", metadata: "purged" };
+    if (personalReviewDispositionLifecycle(disposition) === "pending") {
+        return {
+            excerpt: ageDays >= 30 ? "expired" : "retained",
+            metadata: "retained",
+        };
+    }
+    return {
+        excerpt: "purged",
+        metadata: ageDays >= 90 ? "expired" : "retained",
+    };
+}
+/** Validate the authority-owned private review-record persistence and read contract. */
+export function validatePersonalGlossaryReviewRecordsAuthority(authority) {
+    const mining = mapping(authority.personal_mining_authority);
+    const records = mapping(mining?.review_records);
+    const persistence = mapping(records?.persistence);
+    const compatibility = mapping(persistence?.compatibility);
+    const queue = mapping(records?.queue);
+    const queueCommand = mapping(queue?.command);
+    const request = mapping(queue?.request);
+    const queueResult = mapping(queue?.result);
+    const disposition = mapping(records?.disposition);
+    const dispositionCommand = mapping(disposition?.command);
+    const dispositionRequest = mapping(disposition?.request);
+    const dispositionResult = mapping(disposition?.result);
+    const publicationAuthorization = mapping(disposition?.publication_authorization);
+    const trustedHostKey = mapping(records?.trusted_host_key);
+    const retrieval = mapping(records?.retrieval);
+    const retrievalCommand = mapping(retrieval?.command);
+    const list = mapping(retrieval?.list);
+    const filters = mapping(list?.filters);
+    const cursor = mapping(list?.cursor);
+    const exact = mapping(retrieval?.exact);
+    const maintenance = mapping(records?.maintenance);
+    if (records?.status !== "active" ||
+        records?.owner !== "user_local_review_lifecycle" ||
+        records?.runtime !==
+            "packages/cli/src/analytics/personalGlossaryReviewRecords.ts#queuePersonalGlossaryReviewRecord" ||
+        records?.input !== "current_validated_review_required_cli_decision_and_host_receipt" ||
+        persistence?.root !== "$AGENTERA_PROFILE_DIR/intermediate/personal-glossary" ||
+        persistence?.file !== "review-records.json" ||
+        persistence?.schema_version !== "agentera.personalGlossaryReviewStore.v2" ||
+        persistence?.record_schema_version !== "agentera.personalGlossaryReviewRecord.v2" ||
+        persistence?.owner !== "current_user" ||
+        !sameStrings(persistence?.fields, ["schema_version", "owner", "records", "replay_index", "store_sha256"]) ||
+        !sameStrings(persistence?.record_fields, [
+            "schema_version",
+            "owner",
+            "review_id",
+            "candidate_id",
+            "candidate_revision",
+            "candidate_capsule_sha256",
+            "candidate_projection_sha256",
+            "host_receipt_sha256",
+            "cli_decision_sha256",
+            "semantic_fingerprint",
+            "generation",
+            "policy_version",
+            "scope",
+            "reason",
+            "status",
+            "disposition",
+            "review_record",
+            "reopen_reason",
+            "queued_at",
+            "terminal_at",
+            "expires_at",
+            "record_sha256",
+        ]) ||
+        persistence?.records_max !== 100 ||
+        !sameStrings(persistence?.replay_index_fields, ["nonce_sha256", "receipt_sha256", "expires_at"]) ||
+        persistence?.replay_entries_max !== 100 ||
+        persistence?.record_max_serialized_utf8_bytes !== 8_192 ||
+        persistence?.max_serialized_utf8_bytes !== 1_048_576 ||
+        persistence?.canonicalization !== "candidate_contracts.canonicalization" ||
+        persistence?.order !== "review_id_asc" ||
+        persistence?.replay !== "exact_current_binding_is_unchanged_replay_and_exact_receipt_is_idempotent" ||
+        persistence?.conflict !== "changed_receipt_nonce_binding_or_signature_fails_before_effects" ||
+        !sameStrings(compatibility?.accepted_store_schema_versions, [
+            "agentera.personalGlossaryReviewStore.v1",
+            "agentera.personalGlossaryReviewStore.v2",
+        ]) ||
+        !sameStrings(compatibility?.accepted_record_schema_versions, [
+            "agentera.personalGlossaryPendingReviewRecord.v1",
+            "agentera.personalGlossaryReviewRecord.v2",
+        ]) ||
+        compatibility?.read_mutation !== "forbidden" ||
+        compatibility?.migration_operation !== "disposition_only" ||
+        compatibility?.scope_derivation !== "current_validated_host_receipt_only" ||
+        compatibility?.invalid_behavior !== "fail_before_effects" ||
+        !sameStrings(compatibility?.preserved_bindings, [
+            "review_id",
+            "candidate_id",
+            "candidate_revision",
+            "candidate_capsule_sha256",
+            "candidate_projection_sha256",
+            "host_receipt_sha256",
+            "cli_decision_sha256",
+            "semantic_fingerprint",
+            "generation",
+            "policy_version",
+            "reason",
+        ]) ||
+        compatibility?.legacy_digest !== "validate_before_migration" ||
+        compatibility?.migrated_digest !== "reseal_v2_lifecycle_record" ||
+        !nonEmpty(compatibility?.rule) ||
+        !sameStrings(persistence?.suppression_binding, ["candidate_id", "semantic_fingerprint", "scope", "policy_version"]) ||
+        !sameStrings(persistence?.suppression_dispositions, ["reject", "defer"]) ||
+        !sameStrings(persistence?.reopen_reasons, ["policy_changed", "scope_changed", "meaning_changed"]) ||
+        persistence?.project_storage !== "forbidden" ||
+        !sameStrings(persistence?.forbidden_fields, [
+            "term",
+            "meaning",
+            "excerpt",
+            "raw_evidence",
+            "source_id",
+            "evidence_anchor",
+            "session_id",
+            "project_id",
+            "source_path",
+            "tool_content",
+            "review_approval",
+            "signature",
+            "nonce",
+        ]) ||
+        !nonEmpty(persistence?.rule) ||
+        trustedHostKey?.root !== "$AGENTERA_PROFILE_DIR/intermediate/personal-glossary" ||
+        trustedHostKey?.file !== "trusted-local-host.json" ||
+        trustedHostKey?.schema_version !== "agentera.personalGlossaryTrustedLocalHost.v1" ||
+        !sameStrings(trustedHostKey?.fields, ["schema_version", "owner", "subject", "public_key_spki_base64url"]) ||
+        trustedHostKey?.owner !== "current_user" ||
+        trustedHostKey?.public_key_algorithm !== "ed25519" ||
+        trustedHostKey?.max_serialized_utf8_bytes !== 4_096 ||
+        !nonEmpty(trustedHostKey?.rule) ||
+        queueCommand?.canonical !== "npx -y agentera@next report personal-glossary-reviews" ||
+        queueCommand?.namespace !== "report" ||
+        queueCommand?.input_flag !== "--input" ||
+        queueCommand?.stdin_value !== "-" ||
+        queueCommand?.format !== "json" ||
+        queueCommand?.project_checkout !== "not_required" ||
+        request?.schema_version !== "agentera.personalGlossaryReviewQueueRequest.v1" ||
+        !sameStrings(request?.required_fields, ["schema_version", "receipt"]) ||
+        request?.additional_fields !== "forbidden" ||
+        request?.max_utf8_bytes !== 16_384 ||
+        queue?.decision_outcome !== "review_required" ||
+        !sameStrings(queue?.current_bindings, [
+            "candidate_id",
+            "candidate_revision",
+            "candidate_capsule_sha256",
+            "candidate_projection_sha256",
+            "host_receipt_sha256",
+            "cli_decision_sha256",
+            "semantic_fingerprint",
+            "generation",
+            "policy_version",
+            "reason",
+        ]) ||
+        queueResult?.schema_version !== "agentera.personalGlossaryReviewQueueResult.v1" ||
+        !sameStrings(queueResult?.statuses, ["queued", "unchanged_replay", "suppressed", "reopened"]) ||
+        queueResult?.max_utf8_bytes !== 4_096 ||
+        queue?.no_question_channel !== "queue_without_prompt_or_disposition" ||
+        !nonEmpty(queue?.rule) ||
+        dispositionCommand?.canonical !== "npx -y agentera@next report personal-glossary-reviews" ||
+        dispositionCommand?.namespace !== "report" ||
+        dispositionCommand?.input_flag !== "--input" ||
+        dispositionCommand?.stdin_value !== "-" ||
+        dispositionCommand?.format !== "json" ||
+        dispositionCommand?.project_checkout !== "not_required" ||
+        dispositionRequest?.schema_version !== "agentera.personalGlossaryReviewDispositionRequest.v1" ||
+        !sameStrings(dispositionRequest?.required_fields, ["schema_version", "review_id", "receipt", "approval"]) ||
+        dispositionRequest?.additional_fields !== "forbidden" ||
+        dispositionRequest?.max_utf8_bytes !== 16_384 ||
+        dispositionResult?.schema_version !== "agentera.personalGlossaryReviewDispositionResult.v1" ||
+        !sameStrings(dispositionResult?.statuses, ["disposed", "unchanged_replay"]) ||
+        dispositionResult?.max_utf8_bytes !== 4_096 ||
+        !sameStrings(publicationAuthorization?.dispositions, ["accept", "correct"]) ||
+        !sameStrings(publicationAuthorization?.fields, ["review_id", "review_record_sha256"]) ||
+        !nonEmpty(disposition?.rule) ||
+        retrievalCommand?.canonical !== "npx -y agentera@next report personal-glossary-reviews" ||
+        retrievalCommand?.namespace !== "report" ||
+        retrievalCommand?.format !== "json" ||
+        retrievalCommand?.project_checkout !== "not_required" ||
+        retrieval?.owner !== "current_user" ||
+        retrieval?.schema_version !== "agentera.personalGlossaryReviewRetrieval.v1" ||
+        list?.default_limit !== 20 ||
+        list?.maximum_limit !== 50 ||
+        list?.max_serialized_utf8_bytes !== 32_768 ||
+        list?.order !== "queued_at_desc_then_review_id_asc" ||
+        !sameStrings(filters?.status, ["pending", "terminal"]) ||
+        cursor?.authority !==
+            "references/artifacts/state-storage-authority.yaml#entity_target.public_retrieval.policy.cursor" ||
+        cursor?.vocabulary !== "opaque_snapshot_cursor" ||
+        !sameStrings(cursor?.binding, ["collection", "owner", "filters", "limit", "order", "snapshot"]) ||
+        cursor?.invalid_behavior !== "cursor_invalid" ||
+        cursor?.unavailable_behavior !== "cursor_snapshot_unavailable" ||
+        !nonEmpty(list?.summaries) ||
+        !sameStrings(exact?.required_bindings, [
+            "review_id",
+            "candidate_id",
+            "candidate_revision",
+            "generation",
+            "policy_version",
+        ]) ||
+        exact?.current_binding_field !== "candidate_projection_sha256" ||
+        exact?.max_serialized_utf8_bytes !== 8_192 ||
+        !nonEmpty(exact?.rule) ||
+        !nonEmpty(retrieval?.rule) ||
+        maintenance?.entrypoint !==
+            "packages/cli/src/analytics/personalGlossaryReviewRecords.ts#maintainPersonalGlossaryReviewRecords" ||
+        maintenance?.exposure !== "authenticated_review_owner_only" ||
+        maintenance?.terminal_metadata_days !== 90 ||
+        maintenance?.pending_metadata !== "retained_until_terminal_or_purge" ||
+        maintenance?.cache !== "replay_index_until_receipt_expiry" ||
+        maintenance?.purge !== "current_user_authorized_review_records_only" ||
+        !sameStrings(maintenance?.forbidden_effects, [
+            "profile_entry",
+            "project_state",
+            "candidate_projection",
+            "publication",
+        ]) ||
+        !nonEmpty(maintenance?.rule)) {
+        return [
+            "personal_mining_authority review records must remain bounded, current-user local, privacy-safe, replay-safe, and independently retained",
+        ];
+    }
+    return [];
+}

package/dist/registries/glossaryReviewRecordsContract.js

@@ -0,0 +1,129 @@
+import { loadYamlMappingFile } from "../core/yaml.js";
+import { projectGlossaryDevelopmentValue } from "../core/developmentInvocation.js";
+import { glossaryEntryAuthorityPath } from "./glossaryEntryContract.js";
+function mapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string")
+        ? [...value]
+        : [];
+}
+/** Load the authority-owned private review persistence, retrieval, and maintenance settings. */
+export function personalGlossaryReviewRecordsContract(pathname = glossaryEntryAuthorityPath()) {
+    const authority = loadYamlMappingFile(pathname);
+    const mining = mapping(authority.personal_mining_authority);
+    const records = mapping(mining?.review_records);
+    const persistence = mapping(records?.persistence);
+    const compatibility = mapping(persistence?.compatibility);
+    const queue = mapping(records?.queue);
+    const queueCommand = mapping(queue?.command);
+    const request = mapping(queue?.request);
+    const queueResult = mapping(queue?.result);
+    const disposition = mapping(records?.disposition);
+    const dispositionCommand = mapping(disposition?.command);
+    const dispositionRequest = mapping(disposition?.request);
+    const dispositionResult = mapping(disposition?.result);
+    const publicationAuthorization = mapping(disposition?.publication_authorization);
+    const trustedHostKey = mapping(records?.trusted_host_key);
+    const retrieval = mapping(records?.retrieval);
+    const retrievalCommand = mapping(retrieval?.command);
+    const list = mapping(retrieval?.list);
+    const filters = mapping(list?.filters);
+    const cursor = mapping(list?.cursor);
+    const exact = mapping(retrieval?.exact);
+    const maintenance = mapping(records?.maintenance);
+    const command = projectGlossaryDevelopmentValue(queueCommand?.canonical, "review_records.command");
+    const retrievalCommandValue = projectGlossaryDevelopmentValue(retrievalCommand?.canonical, "review_records.command");
+    if (command !== retrievalCommandValue) {
+        throw new TypeError("invalid development command projection: personal glossary review commands differ");
+    }
+    const dispositionCommandValue = projectGlossaryDevelopmentValue(dispositionCommand?.canonical, "review_records.command");
+    if (command !== dispositionCommandValue) {
+        throw new TypeError("invalid development command projection: personal glossary review disposition commands differ");
+    }
+    return {
+        command,
+        queueRequestSchemaVersion: typeof request?.schema_version === "string" ? request.schema_version : "",
+        queueRequestFields: strings(request?.required_fields),
+        queueMaxRequestUtf8Bytes: typeof request?.max_utf8_bytes === "number" ? request.max_utf8_bytes : 0,
+        queueDecisionOutcome: typeof queue?.decision_outcome === "string" ? queue.decision_outcome : "",
+        queueCurrentBindings: strings(queue?.current_bindings),
+        queueResultSchemaVersion: typeof queueResult?.schema_version === "string" ? queueResult.schema_version : "",
+        queueResultStatuses: strings(queueResult?.statuses),
+        queueMaxResultUtf8Bytes: typeof queueResult?.max_utf8_bytes === "number" ? queueResult.max_utf8_bytes : 0,
+        queueNoQuestionChannel: typeof queue?.no_question_channel === "string" ? queue.no_question_channel : "",
+        dispositionRequestSchemaVersion: typeof dispositionRequest?.schema_version === "string" ? dispositionRequest.schema_version : "",
+        dispositionRequestFields: strings(dispositionRequest?.required_fields),
+        dispositionMaxRequestUtf8Bytes: typeof dispositionRequest?.max_utf8_bytes === "number" ? dispositionRequest.max_utf8_bytes : 0,
+        dispositionResultSchemaVersion: typeof dispositionResult?.schema_version === "string" ? dispositionResult.schema_version : "",
+        dispositionResultStatuses: strings(dispositionResult?.statuses),
+        dispositionMaxResultUtf8Bytes: typeof dispositionResult?.max_utf8_bytes === "number" ? dispositionResult.max_utf8_bytes : 0,
+        dispositionPublicationAuthorizationDispositions: strings(publicationAuthorization?.dispositions),
+        dispositionPublicationAuthorizationFields: strings(publicationAuthorization?.fields),
+        trustedHostKeyFile: typeof trustedHostKey?.file === "string" ? trustedHostKey.file : "",
+        trustedHostKeySchemaVersion: typeof trustedHostKey?.schema_version === "string" ? trustedHostKey.schema_version : "",
+        trustedHostKeyFields: strings(trustedHostKey?.fields),
+        trustedHostKeyOwner: typeof trustedHostKey?.owner === "string" ? trustedHostKey.owner : "",
+        trustedHostKeyAlgorithm: typeof trustedHostKey?.public_key_algorithm === "string" ? trustedHostKey.public_key_algorithm : "",
+        trustedHostKeyMaxSerializedUtf8Bytes: typeof trustedHostKey?.max_serialized_utf8_bytes === "number"
+            ? trustedHostKey.max_serialized_utf8_bytes
+            : 0,
+        storeSchemaVersion: typeof persistence?.schema_version === "string" ? persistence.schema_version : "",
+        recordSchemaVersion: typeof persistence?.record_schema_version === "string" ? persistence.record_schema_version : "",
+        storeOwner: typeof persistence?.owner === "string" ? persistence.owner : "",
+        storeFile: typeof persistence?.file === "string" ? persistence.file : "",
+        storeFields: strings(persistence?.fields),
+        recordFields: strings(persistence?.record_fields),
+        recordsMax: typeof persistence?.records_max === "number" ? persistence.records_max : 0,
+        replayIndexFields: strings(persistence?.replay_index_fields),
+        replayEntriesMax: typeof persistence?.replay_entries_max === "number" ? persistence.replay_entries_max : 0,
+        recordMaxSerializedUtf8Bytes: typeof persistence?.record_max_serialized_utf8_bytes === "number"
+            ? persistence.record_max_serialized_utf8_bytes
+            : 0,
+        storeMaxSerializedUtf8Bytes: typeof persistence?.max_serialized_utf8_bytes === "number"
+            ? persistence.max_serialized_utf8_bytes
+            : 0,
+        storeOrder: typeof persistence?.order === "string" ? persistence.order : "",
+        replay: typeof persistence?.replay === "string" ? persistence.replay : "",
+        conflict: typeof persistence?.conflict === "string" ? persistence.conflict : "",
+        compatibilityStoreSchemaVersions: strings(compatibility?.accepted_store_schema_versions),
+        compatibilityRecordSchemaVersions: strings(compatibility?.accepted_record_schema_versions),
+        compatibilityReadMutation: typeof compatibility?.read_mutation === "string" ? compatibility.read_mutation : "",
+        compatibilityMigrationOperation: typeof compatibility?.migration_operation === "string" ? compatibility.migration_operation : "",
+        compatibilityScopeDerivation: typeof compatibility?.scope_derivation === "string" ? compatibility.scope_derivation : "",
+        compatibilityInvalidBehavior: typeof compatibility?.invalid_behavior === "string" ? compatibility.invalid_behavior : "",
+        compatibilityPreservedBindings: strings(compatibility?.preserved_bindings),
+        compatibilityLegacyDigest: typeof compatibility?.legacy_digest === "string" ? compatibility.legacy_digest : "",
+        compatibilityMigratedDigest: typeof compatibility?.migrated_digest === "string" ? compatibility.migrated_digest : "",
+        suppressionBinding: strings(persistence?.suppression_binding),
+        suppressionDispositions: strings(persistence?.suppression_dispositions),
+        reopenReasons: strings(persistence?.reopen_reasons),
+        forbiddenFields: strings(persistence?.forbidden_fields),
+        retrievalSchemaVersion: typeof retrieval?.schema_version === "string" ? retrieval.schema_version : "",
+        retrievalOwner: typeof retrieval?.owner === "string" ? retrieval.owner : "",
+        listDefaultLimit: typeof list?.default_limit === "number" ? list.default_limit : 0,
+        listMaximumLimit: typeof list?.maximum_limit === "number" ? list.maximum_limit : 0,
+        listMaxSerializedUtf8Bytes: typeof list?.max_serialized_utf8_bytes === "number" ? list.max_serialized_utf8_bytes : 0,
+        listOrder: typeof list?.order === "string" ? list.order : "",
+        listStatuses: strings(filters?.status),
+        cursorAuthority: typeof cursor?.authority === "string" ? cursor.authority : "",
+        cursorVocabulary: typeof cursor?.vocabulary === "string" ? cursor.vocabulary : "",
+        cursorBinding: strings(cursor?.binding),
+        cursorInvalidBehavior: typeof cursor?.invalid_behavior === "string" ? cursor.invalid_behavior : "",
+        cursorUnavailableBehavior: typeof cursor?.unavailable_behavior === "string" ? cursor.unavailable_behavior : "",
+        exactRequiredBindings: strings(exact?.required_bindings),
+        exactCurrentBindingField: typeof exact?.current_binding_field === "string" ? exact.current_binding_field : "",
+        exactMaxSerializedUtf8Bytes: typeof exact?.max_serialized_utf8_bytes === "number"
+            ? exact.max_serialized_utf8_bytes
+            : 0,
+        terminalMetadataDays: typeof maintenance?.terminal_metadata_days === "number"
+            ? maintenance.terminal_metadata_days
+            : 0,
+        maintenanceExposure: typeof maintenance?.exposure === "string" ? maintenance.exposure : "",
+        maintenancePurge: typeof maintenance?.purge === "string" ? maintenance.purge : "",
+        maintenanceForbiddenEffects: strings(maintenance?.forbidden_effects),
+    };
+}