typekro 0.43.0 → 0.44.1

package/dist/core/expressions/magic-proxy/optionality-hydration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"optionality-hydration.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/magic-proxy/optionality-hydration.ts"],"names":[],"mappings":"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"}

package/dist/core/expressions/magic-proxy/optionality-optional-chaining.d.ts

@@ -1,61 +0,0 @@
-/**
- * Optional chaining pattern analysis and CEL generation
- * for the Enhanced Type Optionality Handler.
- *
- * These standalone functions handle analyzing optional chaining patterns
- * in expressions with Enhanced types and generating corresponding CEL expressions.
- */
-import type { KubernetesRef } from '../../types/common.js';
-import type { CelConversionResult } from '../analysis/shared-types.js';
-import type { EnhancedTypeFieldInfo, OptionalChainingPattern, OptionalityContext } from './optionality-types.js';
-/**
- * Analyze optional chaining patterns in expressions with Enhanced types
- */
-export declare function analyzeOptionalChainingPatterns(expression: unknown, context: OptionalityContext): {
-    patterns: OptionalChainingPattern[];
-    enhancedTypeFields: EnhancedTypeFieldInfo[];
-    requiresSpecialHandling: boolean;
-};
-/**
- * Analyze Enhanced type field information
- */
-export declare function analyzeEnhancedTypeField(kubernetesRef: KubernetesRef<unknown>, context: OptionalityContext): EnhancedTypeFieldInfo;
-/**
- * Generate CEL expression for optional chaining with Enhanced types
- */
-export declare function generateOptionalChainingCelExpression(expression: unknown, optionalChainingAnalysis: {
-    patterns: OptionalChainingPattern[];
-    enhancedTypeFields: EnhancedTypeFieldInfo[];
-    requiresSpecialHandling: boolean;
-}, context: OptionalityContext, analyzeAndGenerate: (expr: unknown, ctx: OptionalityContext) => CelConversionResult): CelConversionResult;
-/**
- * Generate Kro CEL expression with ? prefix operator for optional chaining
- *
- * Kro uses the ? operator as a prefix before field names for optional access
- */
-export declare function generateKroOptionalChainingExpression(patterns: OptionalChainingPattern[], _context: OptionalityContext): string;
-/**
- * Convert a field path to Kro's ? prefix optional syntax
- * Example: resources.service.status.loadBalancer.ingress[0].ip
- * Becomes: resources.service.status.?loadBalancer.?ingress[0].?ip
- *
- * The ? operator should be placed before fields that might not exist
- */
-export declare function convertToKroOptionalSyntax(resourcePath: string): string;
-/**
- * Generate has() check expression for optional chaining
- */
-export declare function generateHasCheckOptionalChainingExpression(patterns: OptionalChainingPattern[], _context: OptionalityContext): string;
-/**
- * Generate nested has() checks for a field path
- */
-export declare function generateNestedHasChecksForPath(resourcePath: string): string[];
-/**
- * Calculate chaining depth for a field path
- */
-export declare function calculateChainingDepth(fieldPath: string): number;
-/**
- * Generate optional chaining CEL pattern for a KubernetesRef
- */
-export declare function generateOptionalChainingCelPattern(kubernetesRef: KubernetesRef<unknown>, context: OptionalityContext): string;
-//# sourceMappingURL=optionality-optional-chaining.d.ts.map

package/dist/core/expressions/magic-proxy/optionality-optional-chaining.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"optionality-optional-chaining.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/magic-proxy/optionality-optional-chaining.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAOvE,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,wBAAwB,CAAC;AAEhC;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,kBAAkB,GAC1B;IACD,QAAQ,EAAE,uBAAuB,EAAE,CAAC;IACpC,kBAAkB,EAAE,qBAAqB,EAAE,CAAC;IAC5C,uBAAuB,EAAE,OAAO,CAAC;CAClC,CAkCA;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,EACrC,OAAO,EAAE,kBAAkB,GAC1B,qBAAqB,CAkBvB;AAED;;GAEG;AACH,wBAAgB,qCAAqC,CACnD,UAAU,EAAE,OAAO,EACnB,wBAAwB,EAAE;IACxB,QAAQ,EAAE,uBAAuB,EAAE,CAAC;IACpC,kBAAkB,EAAE,qBAAqB,EAAE,CAAC;IAC5C,uBAAuB,EAAE,OAAO,CAAC;CAClC,EACD,OAAO,EAAE,kBAAkB,EAC3B,kBAAkB,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,KAAK,mBAAmB,GAClF,mBAAmB,CA4DrB;AAED;;;;GAIG;AACH,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,uBAAuB,EAAE,EACnC,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,CAwBR;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CA0BvE;AAED;;GAEG;AACH,wBAAgB,0CAA0C,CACxD,QAAQ,EAAE,uBAAuB,EAAE,EACnC,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,CAqBR;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAU7E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,kCAAkC,CAChD,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,EACrC,OAAO,EAAE,kBAAkB,GAC1B,MAAM,CAcR"}

package/dist/core/expressions/validation/resource-field-utils.d.ts

@@ -1,69 +0,0 @@
-/**
- * Resource Field Utilities
- *
- * Kubernetes field knowledge utilities for resource reference validation.
- * These functions handle field type resolution, field availability checking,
- * similarity matching, and deprecation detection.
- */
-import type { KubernetesRef } from '../../types/common.js';
-import type { Enhanced } from '../../types/kubernetes.js';
-import type { SchemaProxy } from '../../types/serialization.js';
-import type { ResourceValidationMetadata } from './resource-validation-types.js';
-import type { TypeInfo } from './type-safety.js';
-/**
- * Get field type from schema proxy
- */
-export declare function getSchemaFieldType(_schemaProxy: SchemaProxy<Record<string, unknown>, Record<string, unknown>>, _fieldPath: string): TypeInfo | undefined;
-/**
- * Get field type from a resource
- */
-export declare function getResourceFieldType(_resource: Enhanced<unknown, unknown>, fieldPath: string): TypeInfo | undefined;
-/**
- * Get available fields from a schema proxy
- */
-export declare function getAvailableSchemaFields(_schemaProxy: SchemaProxy<Record<string, unknown>, Record<string, unknown>>): string[];
-/**
- * Get available fields from a resource
- */
-export declare function getAvailableResourceFields(resource: Enhanced<unknown, unknown>): string[];
-/**
- * Check if a field path is a common Kubernetes field
- */
-export declare function isCommonKubernetesField(fieldPath: string): boolean;
-/**
- * Find similar field names using string similarity
- */
-export declare function findSimilarFieldNames(target: string, available: string[]): string[];
-/**
- * Find similar resource names using string similarity
- */
-export declare function findSimilarResourceNames(target: string, available: string[]): string[];
-/**
- * Check if a field is deprecated
- */
-export declare function isDeprecatedField(_resource: Enhanced<unknown, unknown>, fieldPath: string): boolean;
-/**
- * Get replacement for a deprecated field
- */
-export declare function getFieldReplacement(_resource: Enhanced<unknown, unknown>, fieldPath: string): string | undefined;
-/**
- * Check if accessing a field has performance implications
- */
-export declare function hasPerformanceImplications(_resource: Enhanced<unknown, unknown>, fieldPath: string): boolean;
-/**
- * Extract API version from a resource
- */
-export declare function getResourceApiVersion(_resource: Enhanced<unknown, unknown>): string | undefined;
-/**
- * Extract kind from a resource
- */
-export declare function getResourceKind(resource: Enhanced<unknown, unknown>): string | undefined;
-/**
- * Get the result type from a reference chain
- */
-export declare function getChainResultType(refs: KubernetesRef<unknown>[]): TypeInfo | undefined;
-/**
- * Create default validation metadata
- */
-export declare function createDefaultMetadata(): ResourceValidationMetadata;
-//# sourceMappingURL=resource-field-utils.d.ts.map

package/dist/core/expressions/validation/resource-field-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resource-field-utils.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/validation/resource-field-utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC3E,UAAU,EAAE,MAAM,GACjB,QAAQ,GAAG,SAAS,CAItB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,SAAS,EAAE,MAAM,GAChB,QAAQ,GAAG,SAAS,CAsDtB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,EAAE,CAG9H;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CA2EzF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAsClE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAQnF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAOtF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAInG;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAQpB;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,SAAS,EAAE,MAAM,GAChB,OAAO,CAIT;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,CAG/F;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,CAGxF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,GAAG,QAAQ,GAAG,SAAS,CAQvF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,0BAA0B,CAUlE"}

package/dist/core/kubernetes/bun-watch.d.ts

@@ -1,30 +0,0 @@
-import * as http from 'node:http';
-import * as https from 'node:https';
-import type * as k8s from '@kubernetes/client-node';
-export interface KubernetesWatch {
-    watch(path: string, queryParams: Record<string, string | number | boolean | undefined>, callback: (phase: string, apiObj: unknown, watchObj: unknown) => void, done: (error: unknown) => void): Promise<{
-        abort(): void;
-    }>;
-}
-export type BunWatchRequestFactory = (protocol: 'http:' | 'https:', options: https.RequestOptions, callback: (response: http.IncomingMessage) => void) => http.ClientRequest;
-/**
- * Streaming Kubernetes watch transport for Bun.
- *
- * The upstream Watch uses node-fetch and passes client certificates through an
- * https.Agent. Bun's fetch compatibility layer does not reliably honor that
- * agent, which turns an authenticated kubeconfig into `system:anonymous`.
- * This implementation applies KubeConfig authentication, extracts the TLS
- * material, and sends it directly through node:https like the ordinary Bun API
- * transport.
- */
-export declare class BunCompatibleWatch implements KubernetesWatch {
-    private readonly kubeConfig;
-    private readonly requestFactory;
-    constructor(kubeConfig: k8s.KubeConfig, requestFactory?: BunWatchRequestFactory);
-    watch(path: string, queryParams: Record<string, string | number | boolean | undefined>, callback: (phase: string, apiObj: unknown, watchObj: unknown) => void, done: (error: unknown) => void): Promise<{
-        abort(): void;
-    }>;
-}
-export declare function createWatchForRuntime(kubeConfig: k8s.KubeConfig): KubernetesWatch;
-export declare function watchErrorMessage(error: unknown): string;
-//# sourceMappingURL=bun-watch.d.ts.map

package/dist/core/kubernetes/bun-watch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bun-watch.d.ts","sourceRoot":"","sources":["../../../src/core/kubernetes/bun-watch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,KAAK,GAAG,MAAM,yBAAyB,CAAC;AAKpD,MAAM,WAAW,eAAe;IAC9B,KAAK,CACH,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,EAClE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,EACrE,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAC7B,OAAO,CAAC;QAAE,KAAK,IAAI,IAAI,CAAA;KAAE,CAAC,CAAC;CAC/B;AAOD,MAAM,MAAM,sBAAsB,GAAG,CACnC,QAAQ,EAAE,OAAO,GAAG,QAAQ,EAC5B,OAAO,EAAE,KAAK,CAAC,cAAc,EAC7B,QAAQ,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,eAAe,KAAK,IAAI,KAC/C,IAAI,CAAC,aAAa,CAAC;AAWxB;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,YAAW,eAAe;IAEtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc;gBADd,UAAU,EAAE,GAAG,CAAC,UAAU,EAC1B,cAAc,GAAE,sBAA8C;IAG3E,KAAK,CACT,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,EAClE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,EACrE,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAC7B,OAAO,CAAC;QAAE,KAAK,IAAI,IAAI,CAAA;KAAE,CAAC;CA+G9B;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,GAAG,eAAe,CAIjF;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKxD"}

package/dist/core/kubernetes/client-node-runtime.d.ts

@@ -1,10 +0,0 @@
-import type * as KubernetesClientNode from '@kubernetes/client-node';
-/**
- * Load the Kubernetes SDK only when a caller actually needs cluster I/O.
- *
- * The SDK's legacy HTTP dependency emits Node's `punycode` deprecation during
- * module evaluation. Keeping it behind this boundary makes TypeKro package
- * imports quiet and avoids loading the full client for planning and YAML work.
- */
-export declare function getKubernetesClientNode(): typeof KubernetesClientNode;
-//# sourceMappingURL=client-node-runtime.d.ts.map

package/dist/core/kubernetes/client-node-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client-node-runtime.d.ts","sourceRoot":"","sources":["../../../src/core/kubernetes/client-node-runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,oBAAoB,MAAM,yBAAyB,CAAC;AAKrE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,oBAAoB,CAGrE"}

package/dist/core/proxy/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Core Proxy Engine
- *
- * Exports the foundational `createResource` function and its options type.
- */
-export type { CreateResourceOptions } from './create-resource.js';
-export { createResource } from './create-resource.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/proxy/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/proxy/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/core/proxy/known-status-fields.d.ts

@@ -1,27 +0,0 @@
-/**
- * Known status fields for standard Kubernetes resource kinds
- *
- * Used by the proxy's status property access trap to detect typos at runtime
- * when debug mode is enabled. Only fires for known K8s kinds — CRDs and
- * cross-composition references have unknown kinds, so no false positives.
- *
- * @see ROADMAP.md Phase 2.12
- */
-/**
- * Check if a status field access looks like a typo of a known field.
- *
- * Returns the closest known field name if the accessed property:
- * 1. Is NOT already a known field for the kind
- * 2. Has a Levenshtein distance ≤ MAX_TYPO_DISTANCE to a known field
- * 3. The kind is in the KNOWN_STATUS_FIELDS registry
- *
- * Returns `null` if no typo is detected (either valid field, unknown kind,
- * or no close match found).
- */
-export declare function detectStatusFieldTypo(kind: string, accessedField: string): string | null;
-/**
- * Get the list of known status fields for a kind.
- * Returns undefined for unknown kinds.
- */
-export declare function getKnownStatusFields(kind: string): readonly string[] | undefined;
-//# sourceMappingURL=known-status-fields.d.ts.map

package/dist/core/proxy/known-status-fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"known-status-fields.d.ts","sourceRoot":"","sources":["../../../src/core/proxy/known-status-fields.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA6IH;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA8BxF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAEhF"}

package/dist/core/readiness/strategy-configuration.d.ts

@@ -1,12 +0,0 @@
-import type { PlanValue } from '../planning/types.js';
-type LiteralValue = string | number | boolean | null;
-export declare function readinessLiteral(value: LiteralValue): PlanValue;
-export declare function readinessConfiguration(entries: Readonly<Record<string, PlanValue | undefined>>): PlanValue;
-export declare function optionalReadinessString(configuration: PlanValue | undefined, key: string): string | undefined;
-export declare function requiredReadinessString(configuration: PlanValue | undefined, key: string): string;
-export declare function optionalReadinessNumber(configuration: PlanValue | undefined, key: string): number | undefined;
-export declare function optionalReadinessBoolean(configuration: PlanValue | undefined, key: string): boolean | undefined;
-export declare function requiredReadinessNumber(configuration: PlanValue | undefined, key: string): number;
-export declare function requiredReadinessBoolean(configuration: PlanValue | undefined, key: string): boolean;
-export {};
-//# sourceMappingURL=strategy-configuration.d.ts.map

package/dist/core/readiness/strategy-configuration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategy-configuration.d.ts","sourceRoot":"","sources":["../../../src/core/readiness/strategy-configuration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,KAAK,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAErD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,CAE/D;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC,CAAC,GACvD,SAAS,CAQX;AASD,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,SAAS,GAAG,SAAS,EACpC,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAGpB;AAED,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,SAAS,GAAG,SAAS,EACpC,GAAG,EAAE,MAAM,GACV,MAAM,CAMR;AAED,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,SAAS,GAAG,SAAS,EACpC,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAGpB;AAED,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,SAAS,GAAG,SAAS,EACpC,GAAG,EAAE,MAAM,GACV,OAAO,GAAG,SAAS,CAGrB;AAED,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,SAAS,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAMjG;AAED,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,SAAS,GAAG,SAAS,EACpC,GAAG,EAAE,MAAM,GACV,OAAO,CAMT"}

package/dist/core/references/cel-lexical-scanner.d.ts

@@ -1,113 +0,0 @@
-/**
- * Preserve offsets while hiding quoted CEL data from reference scanners.
- *
- * "Preserve offsets" is the whole contract, and it is a contract about UTF-16
- * **code units**, because that is what `String.prototype.indexOf`, `slice`,
- * `length` and every `RegExpExecArray.index` in the callers are counted in. So
- * the walk is by code unit — `split('')` — and every blanked unit becomes one
- * space, which makes `maskCelStringLiterals(x).length === x.length` for every
- * input.
- *
- * Iterating by *code point* (`[...expression]`, `Array.from`, `for…of`, a `/u`
- * regex replacing each match with a single space) breaks it silently: an astral
- * character — an emoji, anything above U+FFFF — is one code point and two code
- * units, so blanking it emits one space where the original had two units, and
- * every offset after it drifts by one between the mask and the text it is
- * supposed to index. A caller then slices a fragment one character short, reads
- * a bracket index that points between two tokens, or re-lexes a literal from
- * the wrong place — and only for expressions that happen to contain an emoji
- * inside a string, which is exactly the bug that does not show up in a test
- * suite written in ASCII.
- */
-export declare function maskCelStringLiterals(expression: string): string;
-/** Half-open `[start, end)` range of one closed CEL string literal, quotes included. */
-export interface CelStringLiteralSpan {
-    readonly start: number;
-    readonly end: number;
-}
-/**
- * End of the `STRING_LIT`/`BYTES_LIT` token starting at `at`, or `at` for none.
- *
- * The langdef lexis (cel-spec `doc/langdef.md`) is
- * `STRING_LIT ::= [rR]? ( '"' ~('"'|NEWLINE)* '"' | "'" ~("'"|NEWLINE)* "'"`
- * `| '"""' ~'"""'* '"""' | "'''" ~"'''"* "'''" )` and
- * `BYTES_LIT ::= [bB] STRING_LIT`. cel-go accepts the two prefix letters in
- * either order and in either case, so at most one of each is taken. A prefix
- * letter with no quote behind it is not a string at all and is handed back for
- * `IDENT` to consume, which is what makes `b + "x"` an identifier, an operator
- * and a string rather than a bytes literal.
- *
- * Escapes are lexed in the NON-raw forms only: cel-go's lexer spells the raw
- * forms `RAW '"' ~["\n\r]* '"'`, with no `ESC_SEQ` alternative, so the `"` in
- * `r"a\"` CLOSES the literal. A single-delimiter form cannot span a newline; a
- * triple-quoted one can, and closes at the first matching triple. An
- * unterminated literal is not a token — the caller then steps over the opening
- * quote as ordinary text, which is the behaviour marker-laden template text
- * depends on.
- *
- * This is the STRING-ONLY entry point: it knows nothing about `//` comments, so
- * a caller that runs over text which is not wholly CEL — KRO mixed templates,
- * where `http://` must not read as a comment — can lex the literal family
- * completely without inheriting comment masking. Callers that ARE looking at
- * whole CEL expressions want {@link maskClosedCelLiteralsAndComments} instead.
- */
-export declare function celStringLiteralEnd(text: string, at: number): number;
-/**
- * End of the `COMMENT ::= '//' ~NEWLINE*` starting at `at`, or `at` for none.
- *
- * The comment stops BEFORE its newline, so masking one never disturbs the line
- * structure of a multi-line expression.
- *
- * Exported as the comment half of this lexis, the sibling of
- * {@link celStringLiteralEnd}, for callers that walk a REGION of CEL rather
- * than a whole expression and so cannot use the whole-text masks below. Such a
- * caller owes itself the ordering rule {@link celLiteralRegions} encodes: ask
- * this question and the string question at the same index, in one source-ordered
- * walk, so that a `//` inside a literal opens no comment and a quote inside a
- * comment opens no literal.
- */
-export declare function celLineCommentEnd(text: string, at: number): number;
-/**
- * Locate every CLOSED CEL string literal in `expression`, in source order.
- *
- * The whole `STRING_LIT`/`BYTES_LIT` family is recognised — `r`/`R`/`b`/`B`
- * prefixes in either order, the two triple-quoted forms, escapes in the non-raw
- * forms — and the span INCLUDES the prefix letters, because they are part of
- * the token.
- *
- * The walk is source-ordered and consumes an `IDENT` whole, which is what keeps
- * a prefix letter that merely ENDS an identifier from opening a literal:
- * `ab"x"` is the identifier `ab` followed by a string, never a bytes literal.
- * Restarting the scan at every character cannot make that distinction. A quote
- * inside a `//` comment opens no literal — see {@link celLiteralRegions}.
- *
- * A quote that is never terminated is NOT reported as a literal: callers run
- * over text that is not always well-formed CEL — marker-laden strings derived
- * from template literals may carry a bare apostrophe (`it's ready`) — and
- * swallowing the rest of such a string would silently suppress substitutions
- * in real expression text. Offsets index UTF-16 code units so a caller can
- * splice by them.
- */
-export declare function celStringLiteralSpans(expression: string): CelStringLiteralSpan[];
-/**
- * Blank out every CLOSED CEL string literal AND every `//` line comment.
- *
- * This is what a scanner that REWRITES an expression must read: a token inside
- * quoted data is not a reference, and neither is one inside a comment. Offsets
- * and length are preserved exactly — one space per UTF-16 code unit, newlines
- * left in place — so a caller may match over the masked copy and splice
- * replacements into the original text at the reported offsets.
- */
-export declare function maskClosedCelLiteralsAndComments(expression: string): string;
-export interface CelLambdaScope {
-    readonly variable: string;
-    readonly bodyStart: number;
-    readonly bodyEnd: number;
-}
-/**
- * Locate each lexical CEL collection-macro body without treating a lambda
- * identifier as expression-global.
- */
-export declare function collectCelLambdaScopes(expression: string): CelLambdaScope[];
-export declare function isCelLambdaLocalAt(identifier: string, offset: number, scopes: readonly CelLambdaScope[]): boolean;
-//# sourceMappingURL=cel-lexical-scanner.d.ts.map

package/dist/core/references/cel-lexical-scanner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cel-lexical-scanner.d.ts","sourceRoot":"","sources":["../../../src/core/references/cel-lexical-scanner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAuBhE;AAED,wFAAwF;AACxF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AASD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CA6BpE;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAIlE;AAqDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAIhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,EAAE,CAqB3E;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,cAAc,EAAE,GAChC,OAAO,CAIT"}

package/dist/core/runtime/standalone-operation.d.ts

@@ -1,12 +0,0 @@
-interface StandaloneOperationOptions {
-    readonly abortSignals?: readonly (AbortSignal | undefined)[];
-}
-/**
- * Run one standalone TypeKro operation in one lazily loaded Effect scope.
- *
- * The Promise facade preserves the original rejection value. Effect causes
- * and FiberFailure wrappers never cross the public boundary.
- */
-export declare function runStandaloneOperation<A>(operation: (abortSignal: AbortSignal) => Promise<A>, options?: StandaloneOperationOptions): Promise<A>;
-export {};
-//# sourceMappingURL=standalone-operation.d.ts.map

package/dist/core/runtime/standalone-operation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"standalone-operation.d.ts","sourceRoot":"","sources":["../../../src/core/runtime/standalone-operation.ts"],"names":[],"mappings":"AAAA,UAAU,0BAA0B;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,CAAC;CAC9D;AAsCD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC5C,SAAS,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACnD,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,CAAC,CAAC,CA+BZ"}

package/dist/core/runtime-patches/crd-patcher.d.ts

@@ -1,30 +0,0 @@
-/**
- * CRD Patcher Utilities
- *
- * Provides utilities to patch existing CRDs in a Kubernetes cluster to fix
- * schema validation issues that occur with newer Kubernetes versions (1.33+).
- *
- * This is useful when CRDs were installed before the schema fix was available,
- * and you need to update them without deleting and recreating.
- */
-import type * as k8s from '@kubernetes/client-node';
-/**
- * Check if a CRD needs the schema fix
- */
-export declare function crdNeedsSchemaFix(crd: unknown): boolean;
-/**
- * Patch a CRD in the cluster to fix schema validation issues
- *
- * @param kubeConfig - Kubernetes configuration
- * @param crdName - Name of the CRD to patch (e.g., 'helmreleases.helm.toolkit.fluxcd.io')
- * @returns true if the CRD was patched, false if no patch was needed
- */
-export declare function patchCRDSchema(kubeConfig: k8s.KubeConfig, crdName: string): Promise<boolean>;
-/**
- * Patch all Flux CRDs that need the schema fix
- *
- * @param kubeConfig - Kubernetes configuration
- * @returns Number of CRDs that were patched
- */
-export declare function patchFluxCRDSchemas(kubeConfig: k8s.KubeConfig): Promise<number>;
-//# sourceMappingURL=crd-patcher.d.ts.map

package/dist/core/runtime-patches/crd-patcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crd-patcher.d.ts","sourceRoot":"","sources":["../../../src/core/runtime-patches/crd-patcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,KAAK,GAAG,MAAM,yBAAyB,CAAC;AASpD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAiCvD;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,GAAG,CAAC,UAAU,EAC1B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAoDlB;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBrF"}

package/dist/core/runtime-patches/crd-schema-fix.d.ts

@@ -1,145 +0,0 @@
-/**
- * CRD Schema Fix Utilities
- *
- * Provides utilities to fix CRD schema validation issues that occur with newer
- * Kubernetes versions (1.33+) which have stricter OpenAPI schema validation.
- *
- * ## Background
- *
- * Kubernetes 1.33 introduced stricter validation for CRD schemas. Specifically,
- * when a field uses `x-kubernetes-preserve-unknown-fields: true`, it now requires
- * a `type` field to be present. Many CRDs (including Flux) don't include this,
- * causing 422 validation errors.
- *
- * ## Usage
- *
- * This utility should be used in bootstrap compositions that install CRDs from
- * external sources (like Flux install.yaml) that may not be compatible with
- * newer Kubernetes versions.
- *
- * @example
- * ```typescript
- * import { fixCRDSchemaForK8s133 } from '../../../core/runtime-patches/crd-schema-fix.js';
- *
- * // In a yamlFile transform or custom deployment logic:
- * const fixedManifests = manifests.map(m => fixCRDSchemaForK8s133(m));
- * ```
- *
- * ## Smart Application
- *
- * The `needsCRDSchemaFix` function can be used to check if a CRD actually needs
- * the fix before applying it. This is useful when using 'replace' strategy to
- * avoid overwriting manual patches on existing clusters.
- *
- * @example
- * ```typescript
- * import { needsCRDSchemaFix, fixCRDSchemaForK8s133 } from '../../../core/runtime-patches/crd-schema-fix.js';
- *
- * // Only apply fix if needed
- * const transform = (manifest) => {
- *   if (needsCRDSchemaFix(manifest)) {
- *     return fixCRDSchemaForK8s133(manifest);
- *   }
- *   return manifest;
- * };
- * ```
- */
-import type { KubernetesResource } from '../types/kubernetes.js';
-/**
- * Known field paths that need x-kubernetes-preserve-unknown-fields: true
- * These are fields that accept arbitrary user-defined values (like Helm values)
- */
-/**
- * Known field paths that need x-kubernetes-preserve-unknown-fields: true
- * These are fields that accept arbitrary user-defined values (like Helm values)
- *
- * Shared across crd-schema-fix.ts (manifest transform), crd-patcher.ts (live cluster patching),
- * and yaml-file.ts (CRD JSON patching after deployment).
- */
-export declare const FIELDS_NEEDING_PRESERVE_UNKNOWN: Set<string>;
-/**
- * Result of checking if a CRD needs schema fixes
- */
-export interface CRDSchemaCheckResult {
-    /** Whether the CRD needs any fixes */
-    needsFix: boolean;
-    /** List of issues found that need fixing */
-    issues: string[];
-    /** CRD name if available */
-    crdName?: string;
-}
-/**
- * Recursively check if a schema node needs the preserve-unknown-fields fix.
- *
- * Used by crd-patcher.ts for fast boolean checks before generating patches.
- *
- * @param obj - Schema node to check
- * @param fieldName - Field name for known-field matching
- * @returns true if this node or any descendant needs the fix
- */
-export declare function schemaFieldNeedsFix(obj: any, fieldName?: string): boolean;
-/**
- * Generate JSON patch operations to fix a CRD schema node.
- *
- * Used by crd-patcher.ts (live cluster patching) and yaml-file.ts (post-deployment CRD fixing).
- *
- * @param obj - Schema node to generate patches for
- * @param basePath - JSON pointer base path (e.g., `/spec/versions/0/schema/openAPIV3Schema`)
- * @param fieldName - Field name for known-field matching
- * @returns Array of JSON patch operations
- */
-export declare function generateSchemaFixPatches(obj: any, basePath: string, fieldName?: string): Array<{
-    op: string;
-    path: string;
-    value: unknown;
-}>;
-/**
- * Check if a CRD schema has issues that need fixing for Kubernetes 1.33+
- *
- * This function performs a non-destructive check to determine if a CRD
- * has schema validation issues without modifying the manifest.
- *
- * @param manifest - A Kubernetes resource manifest
- * @returns Check result indicating if fixes are needed and what issues were found
- */
-export declare function needsCRDSchemaFix(manifest: KubernetesResource): CRDSchemaCheckResult;
-/**
- * Fix CRD schema validation issues for Kubernetes 1.33+
- *
- * Kubernetes 1.33 requires a `type` field when `x-kubernetes-preserve-unknown-fields` is used.
- * This function patches CRDs to:
- * 1. Add `type: object` to fields that use `x-kubernetes-preserve-unknown-fields` without a type
- * 2. Add `x-kubernetes-preserve-unknown-fields: true` to known Helm values fields that need it
- *
- * @param manifest - A Kubernetes resource manifest
- * @returns The manifest with CRD schema fixes applied (or unchanged if not a CRD)
- */
-export declare function fixCRDSchemaForK8s133(manifest: KubernetesResource): KubernetesResource;
-/**
- * Apply CRD schema fixes to an array of manifests
- *
- * @param manifests - Array of Kubernetes resource manifests
- * @returns Array with CRD schema fixes applied to any CRDs
- */
-export declare function fixCRDSchemasForK8s133(manifests: KubernetesResource[]): KubernetesResource[];
-/**
- * Smart CRD schema fix that only applies changes when needed
- *
- * This function checks if a CRD actually needs the fix before applying it.
- * This is useful when using 'replace' strategy to avoid overwriting manual
- * patches on existing clusters.
- *
- * @param manifest - A Kubernetes resource manifest
- * @returns The manifest with CRD schema fixes applied only if needed
- */
-export declare function smartFixCRDSchemaForK8s133(manifest: KubernetesResource): KubernetesResource;
-/**
- * Apply smart CRD schema fixes to an array of manifests
- *
- * Only applies fixes to CRDs that actually need them.
- *
- * @param manifests - Array of Kubernetes resource manifests
- * @returns Array with CRD schema fixes applied only where needed
- */
-export declare function smartFixCRDSchemasForK8s133(manifests: KubernetesResource[]): KubernetesResource[];
-//# sourceMappingURL=crd-schema-fix.d.ts.map

package/dist/core/runtime-patches/crd-schema-fix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crd-schema-fix.d.ts","sourceRoot":"","sources":["../../../src/core/runtime-patches/crd-schema-fix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAI9E;;;GAGG;AACH;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,aAI1C,CAAC;AAEH;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,sCAAsC;IACtC,QAAQ,EAAE,OAAO,CAAC;IAClB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AAEH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CA0CzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAEtC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAmDrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,oBAAoB,CAuEpF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,kBAAkB,CA0FtF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,kBAAkB,EAAE,GAAG,kBAAkB,EAAE,CAE5F;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,kBAAkB,GAAG,kBAAkB,CAc3F;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,kBAAkB,EAAE,GAAG,kBAAkB,EAAE,CAEjG"}

package/dist/core/runtime-patches/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Core Utilities
- *
- * Provides utility functions for CRD schema fixes and patching.
- */
-export { crdNeedsSchemaFix, patchCRDSchema, patchFluxCRDSchemas } from './crd-patcher.js';
-export { fixCRDSchemaForK8s133, fixCRDSchemasForK8s133 } from './crd-schema-fix.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/runtime-patches/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/runtime-patches/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/serialization/arktype-ast.d.ts

@@ -1,21 +0,0 @@
-/**
- * Helpers for reading ArkType's JSON AST.
- *
- * ArkType serializes a constraint two different ways depending on whether it
- * carries metadata. Declared plainly it is its own value (`maxLength: 46`);
- * declared with a custom error message — anything configured through
- * `.configure({ message })` — it becomes `{ rule: 46, meta: { message } }`
- * instead. Every consumer that reads the AST has to account for both, or a
- * schema that explains its limit to the caller quietly stops carrying that
- * limit into the artifacts generated from it.
- */
-/**
- * Read the rule out of an ArkType constraint, with or without metadata.
- *
- * Bounds and patterns wrap as `{ rule, meta }`; a domain wraps as
- * `{ domain, meta }`. Anything else — including a flagged pattern
- * (`{ rule, flags }`), which a caller has to see whole in order to reject its
- * flags rather than discard them — is returned unchanged.
- */
-export declare function arkConstraintRule(value: unknown): unknown;
-//# sourceMappingURL=arktype-ast.d.ts.map

package/dist/core/serialization/arktype-ast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arktype-ast.d.ts","sourceRoot":"","sources":["../../../src/core/serialization/arktype-ast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMzD"}