@spottoai/types-package 1.0.2-beta.99 → 1.0.2-dev1138.12

package/dist/esm/common/exactDecimal.js

@@ -0,0 +1,49 @@
+const MAX_DECIMAL_SCALE = 128;
+const powerOfTen = (exponent) => {
+    if (!Number.isSafeInteger(exponent) || exponent < 0 || exponent > MAX_DECIMAL_SCALE) {
+        throw new RangeError(`Decimal scale must be between 0 and ${MAX_DECIMAL_SCALE}.`);
+    }
+    return 10n ** BigInt(exponent);
+};
+const normalize = (coefficient, scale) => {
+    if (coefficient === 0n)
+        return { coefficient: 0n, scale: 0 };
+    let normalizedCoefficient = coefficient;
+    let normalizedScale = scale;
+    while (normalizedScale > 0 && normalizedCoefficient % 10n === 0n) {
+        normalizedCoefficient /= 10n;
+        normalizedScale -= 1;
+    }
+    return { coefficient: normalizedCoefficient, scale: normalizedScale };
+};
+export const parseCanonicalDecimal = (value) => {
+    const negative = value.startsWith('-');
+    const unsigned = negative ? value.slice(1) : value;
+    const [integerDigits, fractionDigits = ''] = unsigned.split('.');
+    if (fractionDigits.length > MAX_DECIMAL_SCALE)
+        throw new RangeError('Decimal scale exceeds the supported bound.');
+    const coefficient = BigInt(`${integerDigits}${fractionDigits}`);
+    return normalize(negative ? -coefficient : coefficient, fractionDigits.length);
+};
+export const addExactDecimalValues = (left, right) => {
+    const scale = Math.max(left.scale, right.scale);
+    return normalize(left.coefficient * powerOfTen(scale - left.scale) + right.coefficient * powerOfTen(scale - right.scale), scale);
+};
+export const subtractExactDecimalValues = (left, right) => addExactDecimalValues(left, { coefficient: -right.coefficient, scale: right.scale });
+export const multiplyExactDecimalValues = (left, right) => normalize(left.coefficient * right.coefficient, left.scale + right.scale);
+export const sumCanonicalDecimals = (values) => values.reduce((total, value) => addExactDecimalValues(total, parseCanonicalDecimal(value)), {
+    coefficient: 0n,
+    scale: 0,
+});
+export const formatExactDecimalValue = (value) => {
+    const normalized = normalize(value.coefficient, value.scale);
+    if (normalized.coefficient === 0n)
+        return '0';
+    const negative = normalized.coefficient < 0n;
+    const digits = (negative ? -normalized.coefficient : normalized.coefficient).toString();
+    if (normalized.scale === 0)
+        return `${negative ? '-' : ''}${digits}`;
+    const padded = digits.padStart(normalized.scale + 1, '0');
+    const split = padded.length - normalized.scale;
+    return `${negative ? '-' : ''}${padded.slice(0, split)}.${padded.slice(split)}`;
+};

package/dist/esm/common/index.js

@@ -0,0 +1,9 @@
+export * from './artifactGeneration.js';
+export * from './capabilityPassport.js';
+export * from './pagination.js';
+export * from './provider.js';
+export * from './providerSyncProgress.js';
+export * from './relationships.js';
+export * from './syncProgress.js';
+export * from './sha256.js';
+export * from './exactDecimal.js';

package/dist/esm/common/pagination.js

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

package/dist/esm/common/provider.js

@@ -0,0 +1,11 @@
+export var ProviderName;
+(function (ProviderName) {
+    ProviderName["Azure"] = "azure";
+    ProviderName["Aws"] = "aws";
+})(ProviderName || (ProviderName = {}));
+/** Provider-owned resource boundary kind used by indexed scope records. */
+export var ProviderScopeType;
+(function (ProviderScopeType) {
+    ProviderScopeType["Subscription"] = "subscription";
+    ProviderScopeType["Account"] = "account";
+})(ProviderScopeType || (ProviderScopeType = {}));

package/dist/esm/common/providerSyncProgress.js

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

package/dist/esm/common/relationships.js

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

package/dist/esm/common/sha256.js

@@ -0,0 +1,89 @@
+/** Browser-safe SHA-256 over a UTF-8 string, returned as lowercase hexadecimal. */
+export function sha256Utf8(value) {
+    let byteLength = 0;
+    for (const character of value) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        byteLength += codePoint < 0x80 ? 1 : codePoint < 0x800 ? 2 : codePoint < 0x10000 ? 3 : 4;
+    }
+    const bytes = new Uint8Array(byteLength);
+    let byteIndex = 0;
+    for (const character of value) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        if (codePoint < 0x80) {
+            bytes[byteIndex++] = codePoint;
+        }
+        else if (codePoint < 0x800) {
+            bytes[byteIndex++] = 0xc0 | (codePoint >>> 6);
+            bytes[byteIndex++] = 0x80 | (codePoint & 0x3f);
+        }
+        else if (codePoint < 0x10000) {
+            bytes[byteIndex++] = 0xe0 | (codePoint >>> 12);
+            bytes[byteIndex++] = 0x80 | ((codePoint >>> 6) & 0x3f);
+            bytes[byteIndex++] = 0x80 | (codePoint & 0x3f);
+        }
+        else {
+            bytes[byteIndex++] = 0xf0 | (codePoint >>> 18);
+            bytes[byteIndex++] = 0x80 | ((codePoint >>> 12) & 0x3f);
+            bytes[byteIndex++] = 0x80 | ((codePoint >>> 6) & 0x3f);
+            bytes[byteIndex++] = 0x80 | (codePoint & 0x3f);
+        }
+    }
+    const paddedLength = Math.ceil((byteLength + 9) / 64) * 64;
+    const bitLengthHigh = Math.floor(byteLength / 0x20000000);
+    const bitLengthLow = (byteLength * 8) >>> 0;
+    const paddedByteAt = (index) => {
+        if (index < byteLength)
+            return bytes[index];
+        if (index === byteLength)
+            return 0x80;
+        if (index < paddedLength - 8)
+            return 0;
+        const lengthIndex = index - (paddedLength - 8);
+        return lengthIndex < 4 ? (bitLengthHigh >>> ((3 - lengthIndex) * 8)) & 0xff : (bitLengthLow >>> ((7 - lengthIndex) * 8)) & 0xff;
+    };
+    const state = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+    const constants = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+        0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+        0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+        0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ];
+    const rotate = (word, bits) => (word >>> bits) | (word << (32 - bits));
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        const schedule = new Array(64);
+        for (let index = 0; index < 16; index++) {
+            const at = offset + index * 4;
+            schedule[index] = (paddedByteAt(at) << 24) | (paddedByteAt(at + 1) << 16) | (paddedByteAt(at + 2) << 8) | paddedByteAt(at + 3);
+        }
+        for (let index = 16; index < 64; index++) {
+            const previous = schedule[index - 15];
+            const recent = schedule[index - 2];
+            const small0 = rotate(previous, 7) ^ rotate(previous, 18) ^ (previous >>> 3);
+            const small1 = rotate(recent, 17) ^ rotate(recent, 19) ^ (recent >>> 10);
+            schedule[index] = (schedule[index - 16] + small0 + schedule[index - 7] + small1) | 0;
+        }
+        let [a, b, c, d, e, f, g, h] = state;
+        for (let index = 0; index < 64; index++) {
+            const large1 = rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25);
+            const choose = (e & f) ^ (~e & g);
+            const temporary1 = (h + large1 + choose + constants[index] + schedule[index]) | 0;
+            const large0 = rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const temporary2 = (large0 + majority) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temporary1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temporary1 + temporary2) | 0;
+        }
+        [a, b, c, d, e, f, g, h].forEach((word, index) => {
+            state[index] = (state[index] + word) | 0;
+        });
+    }
+    return state.map(word => (word >>> 0).toString(16).padStart(8, '0')).join('');
+}

package/dist/esm/common/syncProgress.js

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

package/dist/esm/company/billingAccount.js

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

package/dist/esm/company/company.js

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

package/dist/esm/company/companyHierarchy.js

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

package/dist/esm/company/companyNotes.js

@@ -0,0 +1,38 @@
+export const COMPANY_NOTE_SCHEMA_VERSION = 1;
+export const COMPANY_NOTES_FEATURE_KEY = 'company_notes';
+export const COMPANY_NOTES_VIEW_PERMISSION_KEY = 'company_notes.view';
+export const COMPANY_NOTES_MANAGE_PERMISSION_KEY = 'company_notes.manage';
+export const COMPANY_NOTES_PERMISSION_KEYS = [COMPANY_NOTES_VIEW_PERMISSION_KEY, COMPANY_NOTES_MANAGE_PERMISSION_KEY];
+export const COMPANY_NOTE_ORDINARY_CATEGORIES = ['general', 'meeting'];
+export const COMPANY_NOTE_CONTEXT_CATEGORIES = [
+    'company-profile',
+    'security',
+    'architecture',
+    'operations',
+    'finops',
+    'performance',
+    'reliability',
+    'roadmap',
+];
+export const COMPANY_NOTE_CONTEXT_CATEGORY_ORDER = COMPANY_NOTE_CONTEXT_CATEGORIES;
+export const COMPANY_NOTE_CATEGORIES = [...COMPANY_NOTE_ORDINARY_CATEGORIES, ...COMPANY_NOTE_CONTEXT_CATEGORIES];
+export const COMPANY_NOTE_MEETING_TEMPLATE_KEY = 'meeting-v1';
+export const COMPANY_NOTE_CONTEXT_TEMPLATE_KEYS = [
+    'company-profile-v1',
+    'security-v1',
+    'architecture-v1',
+    'operations-v1',
+    'finops-v1',
+    'performance-v1',
+    'reliability-v1',
+    'roadmap-v1',
+];
+export const COMPANY_NOTE_TEMPLATE_KEYS = [COMPANY_NOTE_MEETING_TEMPLATE_KEY, ...COMPANY_NOTE_CONTEXT_TEMPLATE_KEYS];
+export const COMPANY_NOTES_AI_MODES = [
+    'general-note',
+    'template-draft',
+    'section-draft',
+    'coach-selection',
+    'company-research',
+];
+export const COMPANY_NOTES_AI_SOURCE_MODES = ['spotto-only', 'public-research'];

package/dist/esm/company/customProperties.js

@@ -0,0 +1 @@
+export * from '../customProperties/index.js';

package/dist/esm/company/index.js

@@ -0,0 +1,6 @@
+export * from './company.js';
+export * from './companyHierarchy.js';
+export * from './notification.js';
+export * from './survey.js';
+export * from './billingAccount.js';
+export * from './companyNotes.js';

package/dist/esm/company/notification.js

@@ -0,0 +1,43 @@
+/** Bitmask constants for resources */
+export const RECOMMENDATION_FLAGS = {
+    /** 001 */
+    PRIORITIZED: 1,
+    /** 010 */
+    DISMISSED: 2,
+    /** 100 */
+    NEW: 4,
+    /** 1000 */
+    IMPLEMENTED: 8,
+};
+/** Bitmask constants for users */
+export const USER_FLAGS = {
+    /** 001 */
+    INVITE_ACCEPTED: 1,
+};
+/** Bitmask constants for cloud accounts */
+export const CLOUD_ACCOUNT_FLAGS = {
+    /** 001 */
+    SYNC_COMPLETED: 1,
+};
+export const COST_ANOMALY_FLAGS = {
+    /** 001 */
+    DETECTED: 1,
+};
+export const SHARING_FLAGS = {
+    SHARE_CREATED: 1,
+};
+/** Helper functions for bitmask operations */
+export const hasFlag = (value, flag) => (value & flag) !== 0;
+export const addFlag = (value, flag) => value | flag;
+export const removeFlag = (value, flag) => value & ~flag;
+/** Array helper functions */
+export const hasArrayFlag = (array, flag) => array.includes(flag);
+export const addArrayFlag = (array, flag) => (array.includes(flag) ? array : [...array, flag]);
+export const removeArrayFlag = (array, flag) => array.filter(f => f !== flag);
+/** Get individual flags from resources array */
+export const getRecommendationsFlags = (array) => ({
+    new: hasArrayFlag(array, RECOMMENDATION_FLAGS.NEW),
+    dismissed: hasArrayFlag(array, RECOMMENDATION_FLAGS.DISMISSED),
+    prioritized: hasArrayFlag(array, RECOMMENDATION_FLAGS.PRIORITIZED),
+    implemented: hasArrayFlag(array, RECOMMENDATION_FLAGS.IMPLEMENTED),
+});

package/dist/esm/company/survey.js

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

package/dist/esm/customProperties/customProperties.js

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

package/dist/esm/customProperties/index.js

@@ -0,0 +1 @@
+export * from './customProperties.js';

package/dist/esm/entries/aws.js

@@ -0,0 +1,3 @@
+export * from '../aws/index.js';
+import * as namespace from '../aws/index.js';
+export default namespace;

package/dist/esm/entries/commitments-planning.js

@@ -0,0 +1,3 @@
+export * from '../aws/commitments-planning.js';
+import * as namespace from '../aws/commitments-planning.js';
+export default namespace;

package/dist/esm/entries/environment.js

@@ -0,0 +1,3 @@
+export * from '../environment/index.js';
+import * as namespace from '../environment/index.js';
+export default namespace;

package/dist/esm/entries/provider.js

@@ -0,0 +1,3 @@
+export * from '../common/provider.js';
+import * as namespace from '../common/provider.js';
+export default namespace;

package/dist/esm/entries/recommendations.js

@@ -0,0 +1,3 @@
+export * from '../azure/recommendations.js';
+import * as namespace from '../azure/recommendations.js';
+export default namespace;

package/dist/esm/entries/relationships.js

@@ -0,0 +1,3 @@
+export * from '../aws/portalRelationshipPublicArtifactValidation.js';
+import * as namespace from '../aws/portalRelationshipPublicArtifactValidation.js';
+export default namespace;

package/dist/esm/entries/root.js

@@ -0,0 +1,3 @@
+export * from '../index.js';
+import * as namespace from '../index.js';
+export default namespace;

package/dist/esm/environment/canonicalization.js

@@ -0,0 +1,34 @@
+import { isEnvironmentDocumentDescriptorSetV1, isEnvironmentScopeV1 } from './validation.js';
+const compareUnicodeCodePoints = (left, right) => {
+    const leftPoints = Array.from(left, character => character.codePointAt(0));
+    const rightPoints = Array.from(right, character => character.codePointAt(0));
+    const length = Math.min(leftPoints.length, rightPoints.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = leftPoints[index] - rightPoints[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return leftPoints.length - rightPoints.length;
+};
+/**
+ * Builds the canonical scope-qualified artifact subject used inside opaque
+ * logical references. The JSON tuple is an identifier, never a storage path.
+ */
+export const buildEnvironmentScopeQualifiedSubjectV1 = (scope) => {
+    if (!isEnvironmentScopeV1(scope))
+        throw new TypeError('Invalid V1 environment scope.');
+    return JSON.stringify([scope.kind, scope.tenantId, scope.companyId, scope.subscriptionId]);
+};
+/**
+ * Produces the exact compact UTF-8 tree-digest preimage. Hashing remains the
+ * caller's responsibility so this helper stays browser-safe.
+ */
+export const buildEnvironmentTreeDigestPreimageV1 = (descriptors) => {
+    if (!isEnvironmentDocumentDescriptorSetV1(descriptors)) {
+        throw new TypeError('V1 environment tree digests require each allowlisted document exactly once.');
+    }
+    const pairs = descriptors
+        .map(descriptor => [descriptor.name, descriptor.contentSha256])
+        .sort((left, right) => compareUnicodeCodePoints(left[0], right[0]));
+    return JSON.stringify(pairs);
+};

package/dist/esm/environment/contracts.js

@@ -0,0 +1,69 @@
+/** Single pre-release multi-pillar environment contract shared by producers and consumers. */
+export const ENVIRONMENT_CONTRACT_LIMITS_V1 = Object.freeze({
+    completedPointerBytes: 16 * 1024,
+    projectionBytes: 256 * 1024,
+    environmentIndexBytes: 8 * 1024,
+    pillarDocumentBytes: 8 * 1024,
+    boundedListItems: 50,
+    /**
+     * Row cap for the optional structured detail sections. Deliberately far below
+     * `boundedListItems`: the core lists already consume most of the projection byte budget,
+     * and a detail section is a summary, not an inventory.
+     */
+    sectionListItems: 10,
+    customerStringScalars: 4096,
+    safeLabelScalars: 512,
+    scopeIdentifierScalars: 2048,
+    environmentRunIdAsciiCharacters: 128,
+    sourceIdentityScalars: 256,
+    logicalReferencePayloadBytes: 4 * 1024,
+    validatedContainerDepth: 10,
+});
+export const ENVIRONMENT_PILLARS_V1 = ['cost', 'security', 'governance', 'reliability', 'performance', 'operations'];
+export const ENVIRONMENT_DOCUMENT_NAMES_V1 = [
+    'projection.json',
+    'environment-index.md',
+    'pillars/cost.md',
+    'pillars/security.md',
+    'pillars/governance.md',
+    'pillars/reliability.md',
+    'pillars/performance.md',
+    'pillars/operations.md',
+];
+export const ENVIRONMENT_ARTIFACT_KINDS_V1 = [
+    'subscription-summary',
+    'subscription-resources',
+    'subscription-recommendations',
+    'subscription-service-retirements',
+    'subscription-monitor-alerts',
+    'subscription-data-protection',
+    'subscription-system-tracks',
+    'subscription-metrics',
+    // API-issued evidence kind: a bounded projection of one compiled `projection.json` detail section
+    // (commitments, budgets, idle resources, ...). Never emitted by the compiler as a source reference.
+    'subscription-projection',
+    'tenant-governance',
+    'tenant-governance-access',
+    'tenant-reservations',
+    'tenant-savings-plans',
+    'tenant-applications',
+    'tenant-service-principals',
+];
+export const ENVIRONMENT_FINDING_KINDS_V1 = [
+    'recommendation',
+    'security-posture',
+    'public-exposure',
+    'governance',
+    'compliance',
+    'service-retirement',
+    'data-protection',
+    'health',
+    'performance',
+    'scaling',
+    'operations',
+    'monitoring',
+    'topology',
+];
+export const ENVIRONMENT_SEVERITIES_V1 = ['critical', 'high', 'medium', 'low', 'informational', 'unknown'];
+export const ENVIRONMENT_IMPACTS_V1 = ['high', 'medium', 'low', 'unknown'];
+export const ENVIRONMENT_EFFORTS_V1 = ['high', 'medium', 'low', 'unknown'];

package/dist/esm/environment/index.js

@@ -0,0 +1,5 @@
+export * from './contracts.js';
+export * from './references.js';
+export * from './validation.js';
+export * from './canonicalization.js';
+export * from './tenant.js';

package/dist/esm/environment/internal.js

@@ -0,0 +1,97 @@
+import { ENVIRONMENT_CONTRACT_LIMITS_V1 } from './contracts.js';
+export const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
+export const ENVIRONMENT_RUN_ID_PATTERN = /^[A-Za-z0-9._-]+$/u;
+export const DECIMAL_PATTERN = /^(?:0|[1-9]\d*)(?:\.\d+)?$/u;
+export const CURRENCY_PATTERN = /^[A-Z]{3}$/u;
+export const PROTOTYPE_KEYS = new Set(['__proto__', 'prototype', 'constructor']);
+export const hasControlCharacter = (value) => {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f))
+            return true;
+    }
+    return false;
+};
+export const isRecord = (value) => {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+export const hasExactKeys = (value, required, optional = []) => {
+    const allowed = new Set([...required, ...optional]);
+    const keys = Object.keys(value);
+    return required.every(key => Object.prototype.hasOwnProperty.call(value, key)) && keys.every(key => allowed.has(key) && !PROTOTYPE_KEYS.has(key));
+};
+const scalarLength = (value) => {
+    let count = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const trailing = value.charCodeAt(index + 1);
+            if (!(trailing >= 0xdc00 && trailing <= 0xdfff))
+                return null;
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return null;
+        }
+        count += 1;
+    }
+    return count;
+};
+export const isBoundedString = (value, maximumScalars, options = {}) => {
+    if (typeof value !== 'string')
+        return false;
+    if (options.trimmed && (value.length === 0 || value.trim() !== value))
+        return false;
+    if (options.controls && hasControlCharacter(value))
+        return false;
+    const length = scalarLength(value);
+    return length !== null && length <= maximumScalars;
+};
+export const isCustomerString = (value) => isBoundedString(value, ENVIRONMENT_CONTRACT_LIMITS_V1.customerStringScalars, { controls: true });
+export const isSafeLabel = (value) => isBoundedString(value, ENVIRONMENT_CONTRACT_LIMITS_V1.safeLabelScalars, { trimmed: true, controls: true });
+export const isScopeIdentifier = (value) => isBoundedString(value, ENVIRONMENT_CONTRACT_LIMITS_V1.scopeIdentifierScalars, { trimmed: true, controls: true });
+export const isSourceIdentity = (value) => isBoundedString(value, ENVIRONMENT_CONTRACT_LIMITS_V1.sourceIdentityScalars, { trimmed: true, controls: true });
+export const isNonNegativeInteger = (value) => Number.isSafeInteger(value) && value >= 0;
+export const isCanonicalUtcTimestamp = (value) => {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(value))
+        return false;
+    const milliseconds = Date.parse(value);
+    return Number.isFinite(milliseconds) && new Date(milliseconds).toISOString() === value;
+};
+export const utf8ByteLength = (value) => {
+    let bytes = 0;
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint <= 0x7f)
+            bytes += 1;
+        else if (codePoint <= 0x7ff)
+            bytes += 2;
+        else if (codePoint <= 0xffff)
+            bytes += 3;
+        else
+            bytes += 4;
+    }
+    return bytes;
+};
+export const hasSafeContainerShape = (value, depth = 0, seen = new Set()) => {
+    if (depth > ENVIRONMENT_CONTRACT_LIMITS_V1.validatedContainerDepth)
+        return false;
+    if (typeof value !== 'object' || value === null)
+        return true;
+    if (seen.has(value))
+        return false;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const valid = value.length <= ENVIRONMENT_CONTRACT_LIMITS_V1.boundedListItems && value.every(item => hasSafeContainerShape(item, depth + 1, seen));
+        seen.delete(value);
+        return valid;
+    }
+    if (!isRecord(value))
+        return false;
+    const valid = Object.keys(value).every(key => !PROTOTYPE_KEYS.has(key) && hasSafeContainerShape(value[key], depth + 1, seen));
+    seen.delete(value);
+    return valid;
+};