veryfront 0.1.1239 → 0.1.1241

package/esm/src/schedule/validation.js

@@ -1,12 +1,27 @@
 import { SCHEDULE_CONFIG_INVALID, VeryfrontError } from "../errors/index.js";
 import { agentConversationDiagnostic, conversationConflictDiagnostic, declarationConflictDiagnostic, resolveTriggerTarget, triggerTargetKeys, } from "../trigger/target.js";
 import { snapshotSerializable, validateTriggerId } from "../trigger/validation.js";
+import { isProxyWithoutHooks } from "../platform/compat/error-introspection.js";
 import { isSupportedIanaTimezone, normalizeCronExpression } from "./calendar.js";
-const CONCURRENCY_POLICIES = new Set([
-    "Allow",
-    "Forbid",
-    "Replace",
-]);
+const arrayIsArray = Array.isArray;
+const ARRAY_PROTOTYPE = Array.prototype;
+const OBJECT_PROTOTYPE = Object.prototype;
+const jsonStringify = JSON.stringify;
+const numberIsSafeInteger = Number.isSafeInteger;
+const objectCreate = Object.create;
+const objectDefineProperty = Object.defineProperty;
+const objectFreeze = Object.freeze;
+const objectHasOwn = Object.hasOwn;
+const objectKeys = Object.keys;
+const reflectApply = Reflect.apply;
+const reflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor;
+const reflectGetPrototypeOf = Reflect.getPrototypeOf;
+const reflectOwnKeys = Reflect.ownKeys;
+const regExpExec = RegExp.prototype.exec;
+const StringConstructor = String;
+const stringCharCodeAt = String.prototype.charCodeAt;
+const stringSlice = String.prototype.slice;
+const stringTrim = String.prototype.trim;
 const INTEGRATION_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
 const REQUIREMENT_KIND_PATTERN = /^[a-z][a-z0-9_-]*$/;
 const MAX_INTEGRATION_REQUIREMENTS = 20;
@@ -23,7 +38,6 @@ const MAX_TIMEZONE_LENGTH = 255;
 const MAX_AGENT_PROMPT_LENGTH = 20_000;
 const MAX_DIAGNOSTIC_KEY_LENGTH = 80;
 const SIMPLE_DIAGNOSTIC_KEY_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$-]*$/;
-const LEGACY_TARGET_KEYS = new Set(["conversationMode", "conversationId"]);
 const CONFIG_KEYS = [
     "id",
     "name",
@@ -42,6 +56,17 @@ const CONFIG_KEYS = [
     "integrationRequirements",
 ];
 const DEFINITION_KEYS = CONFIG_KEYS.filter((key) => key !== "cron");
+function defineArrayElement(target, index, value) {
+    objectDefineProperty(target, index, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+function matches(pattern, value) {
+    return reflectApply(regExpExec, pattern, [value]) !== null;
+}
 function invalid(detail, cause) {
     throw SCHEDULE_CONFIG_INVALID.create({
         detail,
@@ -51,42 +76,55 @@ function invalid(detail, cause) {
 function truncateDiagnosticKey(key) {
     if (key.length <= MAX_DIAGNOSTIC_KEY_LENGTH)
         return key;
-    let prefix = key.slice(0, MAX_DIAGNOSTIC_KEY_LENGTH);
-    const finalCodeUnit = prefix.charCodeAt(prefix.length - 1);
+    let prefix = reflectApply(stringSlice, key, [0, MAX_DIAGNOSTIC_KEY_LENGTH]);
+    const finalCodeUnit = reflectApply(stringCharCodeAt, prefix, [prefix.length - 1]);
     if (finalCodeUnit >= 0xd800 && finalCodeUnit <= 0xdbff) {
-        prefix = prefix.slice(0, -1);
+        prefix = reflectApply(stringSlice, prefix, [0, -1]);
     }
     return `${prefix}…`;
 }
 function formatDiagnosticProperty(label, key) {
     const boundedKey = truncateDiagnosticKey(key);
-    return SIMPLE_DIAGNOSTIC_KEY_PATTERN.test(boundedKey)
+    return matches(SIMPLE_DIAGNOSTIC_KEY_PATTERN, boundedKey)
         ? `${label}.${boundedKey}`
-        : `${label}[${JSON.stringify(boundedKey)}]`;
+        : `${label}[${jsonStringify(boundedKey)}]`;
 }
 function snapshotDataRecord(value, label, allowedKeys) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
+    if (!value || typeof value !== "object" || arrayIsArray(value)) {
         invalid(`${label} must be an object.`);
     }
-    const prototype = Reflect.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
+    if (isProxyWithoutHooks(value)) {
+        invalid(`${label} is invalid.`);
+    }
+    const prototype = reflectGetPrototypeOf(value);
+    if (prototype !== OBJECT_PROTOTYPE && prototype !== null) {
         invalid(`${label} must be a plain object.`);
     }
-    const allowed = new Set(allowedKeys);
-    const ownKeys = Reflect.ownKeys(value);
-    for (const key of ownKeys) {
+    const allowed = objectCreate(null);
+    for (let index = 0; index < allowedKeys.length; index++) {
+        allowed[allowedKeys[index]] = true;
+    }
+    const ownKeys = reflectOwnKeys(value);
+    for (let index = 0; index < ownKeys.length; index++) {
+        const key = ownKeys[index];
         if (typeof key === "symbol") {
             invalid(`${label} must not define symbol properties.`);
         }
-        if (!allowed.has(key)) {
+        if (!objectHasOwn(allowed, key)) {
             invalid(`${formatDiagnosticProperty(label, key)} is not supported.`);
         }
     }
-    const listedKeys = new Set(ownKeys);
-    const snapshot = Object.create(null);
-    for (const key of allowedKeys) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-        const listed = listedKeys.has(key);
+    const listedKeys = objectCreate(null);
+    for (let index = 0; index < ownKeys.length; index++) {
+        const key = ownKeys[index];
+        if (typeof key === "string")
+            listedKeys[key] = true;
+    }
+    const snapshot = objectCreate(null);
+    for (let index = 0; index < allowedKeys.length; index++) {
+        const key = allowedKeys[index];
+        const descriptor = reflectGetOwnPropertyDescriptor(value, key);
+        const listed = objectHasOwn(listedKeys, key);
         const descriptorExists = descriptor !== undefined;
         if (listed !== descriptorExists) {
             invalid(`${label} is invalid.`);
@@ -107,7 +145,7 @@ function requireString(value, label) {
     return value;
 }
 function requirePositiveInteger(value, label) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    if (typeof value !== "number" || !numberIsSafeInteger(value) || value <= 0) {
         invalid(`${label} must be a positive integer within the safe integer range.`);
     }
     return value;
@@ -116,7 +154,7 @@ function optionalPositiveInteger(value, label) {
     return value === undefined ? undefined : requirePositiveInteger(value, label);
 }
 function requireNonNegativeInteger(value, label) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    if (typeof value !== "number" || !numberIsSafeInteger(value) || value < 0) {
         invalid(`${label} must be a non-negative integer within the safe integer range.`);
     }
     return value;
@@ -126,7 +164,7 @@ function optionalNonNegativeInteger(value, label) {
 }
 function assertNoControlCharacters(value, label) {
     for (let index = 0; index < value.length; index++) {
-        const codeUnit = value.charCodeAt(index);
+        const codeUnit = reflectApply(stringCharCodeAt, value, [index]);
         if (codeUnit <= 0x1f || codeUnit === 0x7f) {
             invalid(`${label} must not contain control characters.`);
         }
@@ -140,7 +178,7 @@ function requireContractString(value, label, maxLength, mode) {
         invalid(`${label} must be at most ${maxLength} characters.`);
     }
     const original = value;
-    const normalized = original.trim();
+    const normalized = reflectApply(stringTrim, original, []);
     if (normalized.length === 0)
         invalid(`${label} is required.`);
     assertNoControlCharacters(normalized, label);
@@ -158,30 +196,32 @@ function optionalContractString(value, label, maxLength, mode) {
 }
 function requireIntegrationName(value, label, mode) {
     const normalized = requireContractString(value, label, MAX_INTEGRATION_NAME_LENGTH, mode);
-    if (!INTEGRATION_NAME_PATTERN.test(normalized)) {
+    if (!matches(INTEGRATION_NAME_PATTERN, normalized)) {
         invalid(`${label} must use a lowercase integration identifier.`);
     }
     return normalized;
 }
 function requireRequirementKind(value, label, mode) {
     const normalized = requireContractString(value, label, MAX_RESOURCE_KIND_LENGTH, mode);
-    if (!REQUIREMENT_KIND_PATTERN.test(normalized)) {
+    if (!matches(REQUIREMENT_KIND_PATTERN, normalized)) {
         invalid(`${label} must use a lowercase resource kind.`);
     }
     return normalized;
 }
 function snapshotDataArray(value, label, maxLength) {
-    if (!Array.isArray(value))
+    if (!arrayIsArray(value))
         invalid(`${label} must be an array.`);
-    if (Reflect.getPrototypeOf(value) !== Array.prototype) {
+    if (isProxyWithoutHooks(value))
+        invalid(`${label} must be a non-Proxy plain array.`);
+    if (reflectGetPrototypeOf(value) !== ARRAY_PROTOTYPE) {
         invalid(`${label} must be a plain array.`);
     }
-    const lengthDescriptor = Reflect.getOwnPropertyDescriptor(value, "length");
+    const lengthDescriptor = reflectGetOwnPropertyDescriptor(value, "length");
     const lengthValue = lengthDescriptor && "value" in lengthDescriptor
         ? lengthDescriptor.value
         : undefined;
     if (typeof lengthValue !== "number" ||
-        !Number.isSafeInteger(lengthValue) ||
+        !numberIsSafeInteger(lengthValue) ||
         lengthValue < 0) {
         invalid(`${label} has an invalid length.`);
     }
@@ -189,22 +229,26 @@ function snapshotDataArray(value, label, maxLength) {
     if (length > maxLength) {
         invalid(`${label} must contain at most ${maxLength} entries.`);
     }
-    const allowedKeys = new Set(["length"]);
+    const allowedKeys = objectCreate(null);
+    allowedKeys.length = true;
     for (let index = 0; index < length; index++) {
-        allowedKeys.add(String(index));
+        allowedKeys[StringConstructor(index)] = true;
     }
-    if (Reflect.ownKeys(value).some((key) => !allowedKeys.has(key))) {
-        invalid(`${label} must not define custom properties.`);
+    const ownKeys = reflectOwnKeys(value);
+    for (let index = 0; index < ownKeys.length; index++) {
+        if (!objectHasOwn(allowedKeys, ownKeys[index])) {
+            invalid(`${label} must not define custom properties.`);
+        }
     }
     const snapshot = [];
     for (let index = 0; index < length; index++) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(value, String(index));
+        const descriptor = reflectGetOwnPropertyDescriptor(value, StringConstructor(index));
         if (descriptor === undefined ||
             !descriptor.enumerable ||
             !("value" in descriptor)) {
             invalid(`${label}[${index}] must be an enumerable data property.`);
         }
-        snapshot.push(descriptor.value);
+        defineArrayElement(snapshot, index, descriptor.value);
     }
     return snapshot;
 }
@@ -213,8 +257,9 @@ function normalizeCron(value, label, mode) {
     if (original.length > MAX_SCHEDULE_EXPRESSION_LENGTH) {
         invalid(`${label} must be at most ${MAX_SCHEDULE_EXPRESSION_LENGTH} characters.`);
     }
-    if (original.trim().length === 0)
+    if (reflectApply(stringTrim, original, []).length === 0) {
         invalid(`${label} is required.`);
+    }
     assertNoControlCharacters(original, label);
     const normalized = normalizeCronExpression(original);
     if (normalized === null) {
@@ -257,7 +302,8 @@ function normalizeAgentMessage(value, target) {
     if (message.prompt === undefined)
         return undefined;
     const prompt = message.prompt;
-    if (typeof prompt !== "string" || prompt.trim().length === 0) {
+    if (typeof prompt !== "string" ||
+        reflectApply(stringTrim, prompt, []).length === 0) {
         invalid("Schedule agentMessage.prompt must be a non-empty string.");
     }
     if (prompt.length > MAX_AGENT_PROMPT_LENGTH) {
@@ -273,7 +319,7 @@ function normalizeAgentMessage(value, target) {
  */
 function legacyScheduleConversation(input) {
     const legacyTarget = input?._schedule_target;
-    if (!legacyTarget || typeof legacyTarget !== "object" || Array.isArray(legacyTarget)) {
+    if (!legacyTarget || typeof legacyTarget !== "object" || arrayIsArray(legacyTarget)) {
         return { conversationMode: undefined, conversationId: undefined };
     }
     const record = legacyTarget;
@@ -301,11 +347,13 @@ export function legacyScheduleTargetDiagnostic(input, conversation) {
     if (legacyTarget === undefined)
         return null;
     if (legacyTarget === null || typeof legacyTarget !== "object" ||
-        Array.isArray(legacyTarget)) {
+        arrayIsArray(legacyTarget)) {
         return `${label} must be an object.`;
     }
-    for (const key of Object.keys(legacyTarget)) {
-        if (!LEGACY_TARGET_KEYS.has(key)) {
+    const legacyKeys = objectKeys(legacyTarget);
+    for (let index = 0; index < legacyKeys.length; index++) {
+        const key = legacyKeys[index];
+        if (key !== "conversationMode" && key !== "conversationId") {
             return `${formatDiagnosticProperty(label, key)} is not supported.`;
         }
     }
@@ -314,7 +362,7 @@ export function legacyScheduleTargetDiagnostic(input, conversation) {
 function normalizeInput(value) {
     if (value === undefined)
         return undefined;
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
+    if (!value || typeof value !== "object" || arrayIsArray(value)) {
         invalid("Schedule input must be an object.");
     }
     try {
@@ -335,43 +383,45 @@ function normalizeScheduleHealth(value) {
         maxStalenessSeconds: requirePositiveInteger(health.maxStalenessSeconds, "Schedule health.maxStalenessSeconds"),
     };
 }
-function normalizeIntegrationResourceParent(value, requirementIndex, resourceIndex, mode) {
+function normalizeIntegrationResourceParent(value, requirementIndex, resourceIndex, mode, definitionLabel) {
     if (value === undefined)
         return undefined;
-    const label = `Schedule integrationRequirements[${requirementIndex}].resources[${resourceIndex}].parent`;
+    const label = `${definitionLabel} integrationRequirements[${requirementIndex}].resources[${resourceIndex}].parent`;
     const parent = snapshotDataRecord(value, label, ["kind", "id"]);
     return {
         kind: requireRequirementKind(parent.kind, `${label}.kind`, mode),
         id: requireContractString(parent.id, `${label}.id`, MAX_RESOURCE_ID_LENGTH, mode),
     };
 }
-function normalizeIntegrationResource(value, requirementIndex, resourceIndex, mode) {
-    const label = `Schedule integrationRequirements[${requirementIndex}].resources[${resourceIndex}]`;
+function normalizeIntegrationResource(value, requirementIndex, resourceIndex, mode, definitionLabel) {
+    const label = `${definitionLabel} integrationRequirements[${requirementIndex}].resources[${resourceIndex}]`;
     const resource = snapshotDataRecord(value, label, ["kind", "id", "parent"]);
-    const parent = normalizeIntegrationResourceParent(resource.parent, requirementIndex, resourceIndex, mode);
+    const parent = normalizeIntegrationResourceParent(resource.parent, requirementIndex, resourceIndex, mode, definitionLabel);
     return {
         kind: requireRequirementKind(resource.kind, `${label}.kind`, mode),
         id: requireContractString(resource.id, `${label}.id`, MAX_RESOURCE_ID_LENGTH, mode),
         ...(parent === undefined ? {} : { parent }),
     };
 }
-function normalizeIntegrationRequirements(value, mode) {
+function normalizeIntegrationRequirements(value, mode, definitionLabel = "Schedule") {
     if (value === undefined)
         return undefined;
-    const requirements = snapshotDataArray(value, "Schedule integrationRequirements", MAX_INTEGRATION_REQUIREMENTS);
-    const integrations = new Set();
-    return requirements.map((value, index) => {
-        const label = `Schedule integrationRequirements[${index}]`;
+    const requirements = snapshotDataArray(value, `${definitionLabel} integrationRequirements`, MAX_INTEGRATION_REQUIREMENTS);
+    const integrations = objectCreate(null);
+    const normalizedRequirements = [];
+    for (let index = 0; index < requirements.length; index++) {
+        const value = requirements[index];
+        const label = `${definitionLabel} integrationRequirements[${index}]`;
         const requirement = snapshotDataRecord(value, label, [
             "integration",
             "requiredScopes",
             "resources",
         ]);
         const integration = requireIntegrationName(requirement.integration, `${label}.integration`, mode);
-        if (integrations.has(integration)) {
-            invalid(`Schedule integrationRequirements contains duplicate integration ${integration}.`);
+        if (objectHasOwn(integrations, integration)) {
+            invalid(`${definitionLabel} integrationRequirements contains duplicate integration ${integration}.`);
         }
-        integrations.add(integration);
+        integrations[integration] = true;
         const requiredScopesValue = requirement.requiredScopes;
         if (mode === "definition" && requiredScopesValue === undefined) {
             invalid(`${label}.requiredScopes must be an array.`);
@@ -382,34 +432,70 @@ function normalizeIntegrationRequirements(value, mode) {
             invalid(`${label}.resources must be an array.`);
         }
         const resources = snapshotDataArray(resourcesValue === undefined ? [] : resourcesValue, `${label}.resources`, MAX_RESOURCES_PER_REQUIREMENT);
-        const normalizedScopes = requiredScopes.map((scope, scopeIndex) => requireContractString(scope, `${label}.requiredScopes[${scopeIndex}]`, MAX_SCOPE_LENGTH, mode));
-        const scopes = new Set();
-        for (const scope of normalizedScopes) {
-            if (scopes.has(scope)) {
+        const normalizedScopes = [];
+        const scopes = objectCreate(null);
+        for (let scopeIndex = 0; scopeIndex < requiredScopes.length; scopeIndex++) {
+            const scope = requireContractString(requiredScopes[scopeIndex], `${label}.requiredScopes[${scopeIndex}]`, MAX_SCOPE_LENGTH, mode);
+            if (objectHasOwn(scopes, scope)) {
                 invalid(`${label}.requiredScopes contains duplicate scope ${scope}.`);
             }
-            scopes.add(scope);
+            scopes[scope] = true;
+            defineArrayElement(normalizedScopes, scopeIndex, scope);
         }
-        const normalizedResources = resources.map((resource, resourceIndex) => normalizeIntegrationResource(resource, index, resourceIndex, mode));
-        const resourceIdentities = new Set();
-        for (const resource of normalizedResources) {
-            const identity = JSON.stringify([
-                resource.kind,
-                resource.id,
-                resource.parent?.kind ?? null,
-                resource.parent?.id ?? null,
-            ]);
-            if (resourceIdentities.has(identity)) {
-                invalid(`${label}.resources contains a duplicate resource identity.`);
+        const normalizedResources = [];
+        for (let resourceIndex = 0; resourceIndex < resources.length; resourceIndex++) {
+            const resource = normalizeIntegrationResource(resources[resourceIndex], index, resourceIndex, mode, definitionLabel);
+            for (let previousIndex = 0; previousIndex < resourceIndex; previousIndex++) {
+                const previous = normalizedResources[previousIndex];
+                if (previous.kind === resource.kind &&
+                    previous.id === resource.id &&
+                    previous.parent?.kind === resource.parent?.kind &&
+                    previous.parent?.id === resource.parent?.id) {
+                    invalid(`${label}.resources contains a duplicate resource identity.`);
+                }
             }
-            resourceIdentities.add(identity);
+            defineArrayElement(normalizedResources, resourceIndex, resource);
         }
-        return {
+        defineArrayElement(normalizedRequirements, index, {
             integration,
             requiredScopes: normalizedScopes,
             resources: normalizedResources,
-        };
-    });
+        });
+    }
+    return normalizedRequirements;
+}
+/**
+ * Validate, detach, and deeply freeze author-facing integration metadata.
+ *
+ * Task and workflow discovery use the same canonical contract as schedules so
+ * all trigger targets reach the API with identical identifiers, limits, and
+ * duplicate handling.
+ */
+export function captureScheduleIntegrationRequirementsConfig(value, definitionLabel = "Schedule") {
+    try {
+        const requirements = normalizeIntegrationRequirements(value, "config", definitionLabel);
+        if (requirements === undefined)
+            return undefined;
+        for (let index = 0; index < requirements.length; index++) {
+            const requirement = requirements[index];
+            objectFreeze(requirement.requiredScopes);
+            for (let resourceIndex = 0; resourceIndex < requirement.resources.length; resourceIndex++) {
+                const resource = requirement.resources[resourceIndex];
+                if (resource.parent !== undefined)
+                    objectFreeze(resource.parent);
+                objectFreeze(resource);
+            }
+            objectFreeze(requirement.resources);
+            objectFreeze(requirement);
+        }
+        return objectFreeze(requirements);
+    }
+    catch (error) {
+        if (error instanceof VeryfrontError && error.slug === SCHEDULE_CONFIG_INVALID.slug) {
+            throw error;
+        }
+        invalid(`${definitionLabel} integrationRequirements is invalid.`, error);
+    }
 }
 function normalizeScheduleUnsafe(value, mode) {
     const config = snapshotDataRecord(value, "Schedule configuration", mode === "config" ? CONFIG_KEYS : DEFINITION_KEYS);
@@ -470,7 +556,8 @@ function normalizeScheduleUnsafe(value, mode) {
     const maxRuns = optionalPositiveInteger(config.maxRuns, "Schedule maxRuns");
     const concurrencyPolicy = config.concurrencyPolicy;
     if (concurrencyPolicy !== undefined &&
-        !CONCURRENCY_POLICIES.has(concurrencyPolicy)) {
+        concurrencyPolicy !== "Allow" && concurrencyPolicy !== "Forbid" &&
+        concurrencyPolicy !== "Replace") {
         invalid("Schedule concurrencyPolicy must be Allow, Forbid, or Replace.");
     }
     const health = normalizeScheduleHealth(config.health);

package/esm/src/schemas/json-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-value.d.ts","sourceRoot":"","sources":["../../../src/src/schemas/json-value.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,gBAAgB,EAAE,GAClB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAE,CAAC;AAExC,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD,MAAM,MAAM,mBAAmB,GAC3B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,GAC1C;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAE,CAAC;AA6DhE;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CA+G5E"}
+{"version":3,"file":"json-value.d.ts","sourceRoot":"","sources":["../../../src/src/schemas/json-value.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA4BH,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,gBAAgB,EAAE,GAClB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAE,CAAC;AAExC,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD,MAAM,MAAM,mBAAmB,GAC3B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,GAC1C;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAE,CAAC;AA4EhE;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CAmH5E"}