@ai-pip/core 0.1.2 → 0.1.3

package/dist/cpe/value-objects/Nonce.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Nonce - Valor único para prevenir ataques de replay
+ * Value Object puro e inmutable
+ */
+/**
+ * Nonce - Valor único generado aleatoriamente
+ */
+export type Nonce = {
+    readonly value: string;
+};
+/**
+ * Genera un nonce único
+ *
+ * @param length - Longitud del nonce en bytes (default: 16)
+ * @returns Nonce único
+ */
+export declare function createNonce(length?: number): Nonce;
+/**
+ * Valida que un string sea un nonce válido
+ *
+ * @param value - String a validar
+ * @returns true si es un nonce válido
+ */
+export declare function isValidNonce(value: string): boolean;
+/**
+ * Compara dos nonces
+ *
+ * @param nonce1 - Primer nonce
+ * @param nonce2 - Segundo nonce
+ * @returns true si son iguales
+ */
+export declare function equalsNonce(nonce1: Nonce, nonce2: Nonce): boolean;
+//# sourceMappingURL=Nonce.d.ts.map

package/dist/cpe/value-objects/Nonce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Nonce.d.ts","sourceRoot":"","sources":["../../../src/cpe/value-objects/Nonce.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,GAAE,MAAW,GAAG,KAAK,CActD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAEjE"}

package/dist/cpe/value-objects/Nonce.js

@@ -0,0 +1,44 @@
+/**
+ * Nonce - Valor único para prevenir ataques de replay
+ * Value Object puro e inmutable
+ */
+import { randomBytes } from 'node:crypto';
+/**
+ * Genera un nonce único
+ *
+ * @param length - Longitud del nonce en bytes (default: 16)
+ * @returns Nonce único
+ */
+export function createNonce(length = 16) {
+    if (length < 8) {
+        throw new Error('Nonce length must be at least 8 bytes');
+    }
+    if (length > 64) {
+        throw new Error('Nonce length must be at most 64 bytes');
+    }
+    const bytes = randomBytes(length);
+    const value = bytes.toString('hex');
+    return Object.freeze({
+        value,
+    });
+}
+/**
+ * Valida que un string sea un nonce válido
+ *
+ * @param value - String a validar
+ * @returns true si es un nonce válido
+ */
+export function isValidNonce(value) {
+    return /^[a-f0-9]{16,128}$/i.test(value);
+}
+/**
+ * Compara dos nonces
+ *
+ * @param nonce1 - Primer nonce
+ * @param nonce2 - Segundo nonce
+ * @returns true si son iguales
+ */
+export function equalsNonce(nonce1, nonce2) {
+    return nonce1.value === nonce2.value;
+}
+//# sourceMappingURL=Nonce.js.map

package/dist/cpe/value-objects/Nonce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Nonce.js","sourceRoot":"","sources":["../../../src/cpe/value-objects/Nonce.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AASzC;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,SAAiB,EAAE;IAC7C,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;IAC1D,CAAC;IACD,IAAI,MAAM,GAAG,EAAE,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAA;IAC1D,CAAC;IAED,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAA;IACjC,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAEnC,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,KAAK;KACN,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,OAAO,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AAC1C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,MAAa,EAAE,MAAa;IACtD,OAAO,MAAM,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,CAAA;AACtC,CAAC"}

package/dist/cpe/value-objects/Signature.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Signature - Firma criptográfica HMAC-SHA256
+ * Value Object puro e inmutable
+ */
+import type { SignatureAlgorithm } from '../types';
+/**
+ * Signature - Firma criptográfica
+ */
+export type SignatureVO = {
+    readonly value: string;
+    readonly algorithm: SignatureAlgorithm;
+};
+/**
+ * Genera una firma HMAC-SHA256 del contenido
+ *
+ * @param content - Contenido a firmar
+ * @param secretKey - Clave secreta para HMAC
+ * @returns Signature inmutable
+ *
+ * @throws {Error} Si la clave secreta está vacía
+ */
+export declare function createSignature(content: string, secretKey: string): SignatureVO;
+/**
+ * Verifica una firma HMAC-SHA256
+ *
+ * @param content - Contenido original
+ * @param signature - Firma a verificar
+ * @param secretKey - Clave secreta para HMAC
+ * @returns true si la firma es válida
+ */
+export declare function verifySignature(content: string, signature: string, secretKey: string): boolean;
+/**
+ * Valida el formato de una firma
+ *
+ * @param signature - Firma a validar
+ * @returns true si el formato es válido
+ */
+export declare function isValidSignatureFormat(signature: string): boolean;
+//# sourceMappingURL=Signature.d.ts.map

package/dist/cpe/value-objects/Signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Signature.d.ts","sourceRoot":"","sources":["../../../src/cpe/value-objects/Signature.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAElD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAA;CACvC,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,WAAW,CAiBb;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAWT;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAGjE"}

package/dist/cpe/value-objects/Signature.js

@@ -0,0 +1,60 @@
+/**
+ * Signature - Firma criptográfica HMAC-SHA256
+ * Value Object puro e inmutable
+ */
+import { createHmac } from 'node:crypto';
+/**
+ * Genera una firma HMAC-SHA256 del contenido
+ *
+ * @param content - Contenido a firmar
+ * @param secretKey - Clave secreta para HMAC
+ * @returns Signature inmutable
+ *
+ * @throws {Error} Si la clave secreta está vacía
+ */
+export function createSignature(content, secretKey) {
+    if (!secretKey || secretKey.length === 0) {
+        throw new Error('Secret key is required for signature generation');
+    }
+    if (typeof content !== 'string') {
+        throw new TypeError('Content must be a string');
+    }
+    const hmac = createHmac('sha256', secretKey);
+    hmac.update(content);
+    const signature = hmac.digest('hex');
+    return Object.freeze({
+        value: signature,
+        algorithm: 'HMAC-SHA256',
+    });
+}
+/**
+ * Verifica una firma HMAC-SHA256
+ *
+ * @param content - Contenido original
+ * @param signature - Firma a verificar
+ * @param secretKey - Clave secreta para HMAC
+ * @returns true si la firma es válida
+ */
+export function verifySignature(content, signature, secretKey) {
+    if (!secretKey || secretKey.length === 0) {
+        return false;
+    }
+    try {
+        const expectedSignature = createSignature(content, secretKey);
+        return expectedSignature.value === signature;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Valida el formato de una firma
+ *
+ * @param signature - Firma a validar
+ * @returns true si el formato es válido
+ */
+export function isValidSignatureFormat(signature) {
+    // HMAC-SHA256 produce un hash hexadecimal de 64 caracteres
+    return /^[a-f0-9]{64}$/i.test(signature);
+}
+//# sourceMappingURL=Signature.js.map

package/dist/cpe/value-objects/Signature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Signature.js","sourceRoot":"","sources":["../../../src/cpe/value-objects/Signature.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAWxC;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAC7B,OAAe,EACf,SAAiB;IAEjB,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAA;IACpE,CAAC;IAED,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,MAAM,IAAI,SAAS,CAAC,0BAA0B,CAAC,CAAA;IACjD,CAAC;IAED,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAA;IAC5C,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACpB,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAEpC,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,KAAK,EAAE,SAAS;QAChB,SAAS,EAAE,aAAa;KACzB,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAC7B,OAAe,EACf,SAAiB,EACjB,SAAiB;IAEjB,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,CAAC;QACH,MAAM,iBAAiB,GAAG,eAAe,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;QAC7D,OAAO,iBAAiB,CAAC,KAAK,KAAK,SAAS,CAAA;IAC9C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,SAAiB;IACtD,2DAA2D;IAC3D,OAAO,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;AAC1C,CAAC"}

package/dist/cpe/value-objects/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CPE Value Objects - Exports
+ */
+export * from './Nonce';
+export * from './Metadata';
+export * from './Signature';
+//# sourceMappingURL=index.d.ts.map

package/dist/cpe/value-objects/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cpe/value-objects/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}

package/dist/cpe/value-objects/index.js

@@ -0,0 +1,7 @@
+/**
+ * CPE Value Objects - Exports
+ */
+export * from './Nonce';
+export * from './Metadata';
+export * from './Signature';
+//# sourceMappingURL=index.js.map

package/dist/cpe/value-objects/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/cpe/value-objects/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}

package/dist/csl/classify.d.ts

@@ -0,0 +1,35 @@
+import type { Origin } from './value-objects/Origin';
+import type { Source } from './types';
+/**
+ * Clasifica un source y retorna su TrustLevel - función pura determinista
+ *
+ * @remarks
+ * - 100% determinista: mismo source → mismo trust level, siempre
+ * - Sin efectos secundarios: función pura
+ * - Sin análisis de contenido: solo el source importa
+ *
+ * @param source - El source del contenido ('DOM' | 'UI' | 'SYSTEM' | 'API')
+ * @returns TrustLevel determinado por el source
+ *
+ * @throws {ClassificationError} Si el source no puede ser clasificado
+ *
+ * @example
+ * ```typescript
+ * const trust = classifySource('UI')
+ * // Returns: { value: 'TC' }
+ *
+ * const trust2 = classifySource('DOM')
+ * // Returns: { value: 'STC' }
+ * ```
+ */
+export declare function classifySource(source: Source): import("./value-objects").TrustLevel;
+/**
+ * Clasifica un Origin y retorna su TrustLevel - función pura determinista
+ *
+ * @param origin - El Origin value object
+ * @returns TrustLevel determinado por el origin
+ *
+ * @throws {ClassificationError} Si el origin no está mapeado
+ */
+export declare function classifyOrigin(origin: Origin): import("./value-objects").TrustLevel;
+//# sourceMappingURL=classify.d.ts.map

package/dist/csl/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/csl/classify.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,wCAyB5C;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,wCAW5C"}

package/dist/csl/classify.js

@@ -0,0 +1,62 @@
+import { createTrustLevel } from './value-objects/TrustLevel';
+import { originMap } from './value-objects/Origin-map';
+import { ClassificationError } from './exceptions';
+import { OriginType } from './types';
+/**
+ * Clasifica un source y retorna su TrustLevel - función pura determinista
+ *
+ * @remarks
+ * - 100% determinista: mismo source → mismo trust level, siempre
+ * - Sin efectos secundarios: función pura
+ * - Sin análisis de contenido: solo el source importa
+ *
+ * @param source - El source del contenido ('DOM' | 'UI' | 'SYSTEM' | 'API')
+ * @returns TrustLevel determinado por el source
+ *
+ * @throws {ClassificationError} Si el source no puede ser clasificado
+ *
+ * @example
+ * ```typescript
+ * const trust = classifySource('UI')
+ * // Returns: { value: 'TC' }
+ *
+ * const trust2 = classifySource('DOM')
+ * // Returns: { value: 'STC' }
+ * ```
+ */
+export function classifySource(source) {
+    // Mapeo simple: Source → OriginType → TrustLevel
+    const sourceToOriginType = {
+        'UI': OriginType.SYSTEM_GENERATED, // UI directa → TC
+        'SYSTEM': OriginType.SYSTEM_GENERATED, // System → TC
+        'DOM': OriginType.DOM_VISIBLE, // DOM → STC
+        'API': OriginType.NETWORK_FETCHED // API → UC
+    };
+    const originType = sourceToOriginType[source];
+    if (!originType) {
+        throw new ClassificationError(`Source '${source}' cannot be classified`);
+    }
+    const trustLevelType = originMap.get(originType);
+    if (!trustLevelType) {
+        throw new ClassificationError(`Origin type '${originType}' is not mapped in originMap. ` +
+            `All OriginType values must have a corresponding TrustLevel mapping.`);
+    }
+    return createTrustLevel(trustLevelType);
+}
+/**
+ * Clasifica un Origin y retorna su TrustLevel - función pura determinista
+ *
+ * @param origin - El Origin value object
+ * @returns TrustLevel determinado por el origin
+ *
+ * @throws {ClassificationError} Si el origin no está mapeado
+ */
+export function classifyOrigin(origin) {
+    const trustLevelType = originMap.get(origin.type);
+    if (!trustLevelType) {
+        throw new ClassificationError(`Origin type '${origin.type}' is not mapped in originMap. ` +
+            `All OriginType values must have a corresponding TrustLevel mapping.`);
+    }
+    return createTrustLevel(trustLevelType);
+}
+//# sourceMappingURL=classify.js.map

package/dist/csl/classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/csl/classify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAE7D,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGpC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,iDAAiD;IACjD,MAAM,kBAAkB,GAA+B;QACrD,IAAI,EAAE,UAAU,CAAC,gBAAgB,EAAO,kBAAkB;QAC1D,QAAQ,EAAE,UAAU,CAAC,gBAAgB,EAAI,cAAc;QACvD,KAAK,EAAE,UAAU,CAAC,WAAW,EAAY,YAAY;QACrD,KAAK,EAAE,UAAU,CAAC,eAAe,CAAQ,WAAW;KACrD,CAAA;IAED,MAAM,UAAU,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAA;IAE7C,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,mBAAmB,CAAC,WAAW,MAAM,wBAAwB,CAAC,CAAA;IAC1E,CAAC;IAED,MAAM,cAAc,GAAG,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAEhD,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,MAAM,IAAI,mBAAmB,CAC3B,gBAAgB,UAAU,gCAAgC;YAC1D,qEAAqE,CACtE,CAAA;IACH,CAAC;IAED,OAAO,gBAAgB,CAAC,cAAc,CAAC,CAAA;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,MAAM,cAAc,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAEjD,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,MAAM,IAAI,mBAAmB,CAC3B,gBAAgB,MAAM,CAAC,IAAI,gCAAgC;YAC3D,qEAAqE,CACtE,CAAA;IACH,CAAC;IAED,OAAO,gBAAgB,CAAC,cAAc,CAAC,CAAA;AACzC,CAAC"}

package/dist/csl/exceptions/ClassificationError.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ClassificationError is thrown when classification fails.
+ *
+ * @remarks
+ * This error is thrown when:
+ * - An origin type is not mapped in originMap
+ * - Classification cannot be determined
+ */
+export declare class ClassificationError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=ClassificationError.d.ts.map

package/dist/csl/exceptions/ClassificationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassificationError.d.ts","sourceRoot":"","sources":["../../../src/csl/exceptions/ClassificationError.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAK5B"}

package/dist/csl/exceptions/ClassificationError.js

@@ -0,0 +1,16 @@
+/**
+ * ClassificationError is thrown when classification fails.
+ *
+ * @remarks
+ * This error is thrown when:
+ * - An origin type is not mapped in originMap
+ * - Classification cannot be determined
+ */
+export class ClassificationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ClassificationError';
+        Object.setPrototypeOf(this, ClassificationError.prototype);
+    }
+}
+//# sourceMappingURL=ClassificationError.js.map

package/dist/csl/exceptions/ClassificationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassificationError.js","sourceRoot":"","sources":["../../../src/csl/exceptions/ClassificationError.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAA;QACjC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAA;IAC5D,CAAC;CACF"}

package/dist/csl/exceptions/SegmentationError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SegmentationError is thrown when the segmentation process fails.
+ *
+ * @remarks
+ * This error is thrown when:
+ * - Content segmentation fails
+ * - Critical pipeline steps fail
+ */
+export declare class SegmentationError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+//# sourceMappingURL=SegmentationError.d.ts.map

package/dist/csl/exceptions/SegmentationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentationError.d.ts","sourceRoot":"","sources":["../../../src/csl/exceptions/SegmentationError.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;aAGxB,KAAK,CAAC,EAAE,OAAO;gBAD/B,OAAO,EAAE,MAAM,EACC,KAAK,CAAC,EAAE,OAAO,YAAA;CAMlC"}

package/dist/csl/exceptions/SegmentationError.js

@@ -0,0 +1,18 @@
+/**
+ * SegmentationError is thrown when the segmentation process fails.
+ *
+ * @remarks
+ * This error is thrown when:
+ * - Content segmentation fails
+ * - Critical pipeline steps fail
+ */
+export class SegmentationError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'SegmentationError';
+        Object.setPrototypeOf(this, SegmentationError.prototype);
+    }
+}
+//# sourceMappingURL=SegmentationError.js.map

package/dist/csl/exceptions/SegmentationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentationError.js","sourceRoot":"","sources":["../../../src/csl/exceptions/SegmentationError.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IAGxB;IAFlB,YACE,OAAe,EACC,KAAe;QAE/B,KAAK,CAAC,OAAO,CAAC,CAAA;QAFE,UAAK,GAAL,KAAK,CAAU;QAG/B,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAA;QAC/B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAA;IAC1D,CAAC;CACF"}

package/dist/csl/exceptions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ClassificationError';
+export * from './SegmentationError';
+//# sourceMappingURL=index.d.ts.map

package/dist/csl/exceptions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/csl/exceptions/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA"}

package/dist/csl/exceptions/index.js

@@ -0,0 +1,3 @@
+export * from './ClassificationError';
+export * from './SegmentationError';
+//# sourceMappingURL=index.js.map

package/dist/csl/exceptions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/csl/exceptions/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA"}

package/dist/csl/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * CSL (Context Segmentation Layer) - Core Semántico
+ *
+ * @remarks
+ * Este es el core semántico de CSL. Solo contiene:
+ * - Funciones puras (sin estado)
+ * - Value objects inmutables
+ * - Tipos y excepciones
+ *
+ * **NO contiene:**
+ * - Detección de prompt injection (va a ISL)
+ * - Políticas (van a ISL)
+ * - Anomaly scores (van a ISL)
+ * - Normalización agresiva (va a ISL)
+ * - Servicios con estado (van al SDK)
+ */
+export { segment } from './segment';
+export { classifySource, classifyOrigin } from './classify';
+export { initLineage, createLineageEntry } from './lineage';
+export * from './value-objects';
+export * from './exceptions';
+export * from './types';
+export { generateId, splitByContextRules } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/csl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/csl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAG3D,cAAc,iBAAiB,CAAA;AAG/B,cAAc,cAAc,CAAA;AAG5B,cAAc,SAAS,CAAA;AAGvB,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA"}

package/dist/csl/index.js

@@ -0,0 +1,29 @@
+/**
+ * CSL (Context Segmentation Layer) - Core Semántico
+ *
+ * @remarks
+ * Este es el core semántico de CSL. Solo contiene:
+ * - Funciones puras (sin estado)
+ * - Value objects inmutables
+ * - Tipos y excepciones
+ *
+ * **NO contiene:**
+ * - Detección de prompt injection (va a ISL)
+ * - Políticas (van a ISL)
+ * - Anomaly scores (van a ISL)
+ * - Normalización agresiva (va a ISL)
+ * - Servicios con estado (van al SDK)
+ */
+// Funciones puras principales
+export { segment } from './segment';
+export { classifySource, classifyOrigin } from './classify';
+export { initLineage, createLineageEntry } from './lineage';
+// Value objects
+export * from './value-objects';
+// Exceptions
+export * from './exceptions';
+// Types
+export * from './types';
+// Utils
+export { generateId, splitByContextRules } from './utils';
+//# sourceMappingURL=index.js.map

package/dist/csl/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/csl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,8BAA8B;AAC9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAE3D,gBAAgB;AAChB,cAAc,iBAAiB,CAAA;AAE/B,aAAa;AACb,cAAc,cAAc,CAAA;AAE5B,QAAQ;AACR,cAAc,SAAS,CAAA;AAEvB,QAAQ;AACR,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA"}

package/dist/csl/lineage.d.ts

@@ -0,0 +1,31 @@
+import type { LineageEntry } from './value-objects/LineageEntry';
+import type { CSLSegment } from './types';
+/**
+ * Inicializa el linaje para un segmento - función pura
+ *
+ * @remarks
+ * Crea la entrada inicial de linaje cuando se crea un segmento en CSL.
+ * El core solo registra step y timestamp, sin notes.
+ *
+ * @param segment - El segmento para el cual inicializar el linaje
+ * @returns Array con la entrada inicial de linaje
+ *
+ * @example
+ * ```typescript
+ * const lineage = initLineage(segment)
+ * // Returns: [{ step: 'CSL', timestamp: ... }]
+ * ```
+ */
+export declare function initLineage(_segment: CSLSegment): LineageEntry[];
+/**
+ * Crea una entrada de linaje - función pura
+ *
+ * @remarks
+ * El core solo registra step y timestamp.
+ * Notes y metadata van en el SDK para observabilidad.
+ *
+ * @param step - Nombre del paso de procesamiento
+ * @returns Nueva entrada de linaje
+ */
+export declare function createLineageEntry(step: string): LineageEntry;
+//# sourceMappingURL=lineage.d.ts.map

package/dist/csl/lineage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage.d.ts","sourceRoot":"","sources":["../../src/csl/lineage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,YAAY,EAAE,CAIhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAE7D"}

package/dist/csl/lineage.js

@@ -0,0 +1,36 @@
+import { createLineageEntry as createEntry } from './value-objects/LineageEntry';
+/**
+ * Inicializa el linaje para un segmento - función pura
+ *
+ * @remarks
+ * Crea la entrada inicial de linaje cuando se crea un segmento en CSL.
+ * El core solo registra step y timestamp, sin notes.
+ *
+ * @param segment - El segmento para el cual inicializar el linaje
+ * @returns Array con la entrada inicial de linaje
+ *
+ * @example
+ * ```typescript
+ * const lineage = initLineage(segment)
+ * // Returns: [{ step: 'CSL', timestamp: ... }]
+ * ```
+ */
+export function initLineage(_segment) {
+    return [
+        createEntry('CSL', Date.now())
+    ];
+}
+/**
+ * Crea una entrada de linaje - función pura
+ *
+ * @remarks
+ * El core solo registra step y timestamp.
+ * Notes y metadata van en el SDK para observabilidad.
+ *
+ * @param step - Nombre del paso de procesamiento
+ * @returns Nueva entrada de linaje
+ */
+export function createLineageEntry(step) {
+    return createEntry(step, Date.now());
+}
+//# sourceMappingURL=lineage.js.map

package/dist/csl/lineage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage.js","sourceRoot":"","sources":["../../src/csl/lineage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,IAAI,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAIhF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CAAC,QAAoB;IAC9C,OAAO;QACL,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;KAC/B,CAAA;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAA;AACtC,CAAC"}

package/dist/csl/segment.d.ts

@@ -0,0 +1,35 @@
+import type { CSLInput, CSLResult } from './types';
+/**
+ * Segmenta input en segmentos semánticos - función pura principal de CSL
+ *
+ * @remarks
+ * Esta es la función principal de CSL. Segmenta el contenido, clasifica
+ * por origen, e inicializa el linaje. Todo de forma pura y determinista.
+ *
+ * **Invariantes preservados:**
+ * - El contenido original nunca se pierde
+ * - El orden de segmentos es estable
+ * - Todo segmento tiene linaje inicial
+ * - CSL es determinista
+ *
+ * @param input - Input con contenido y source
+ * @returns CSLResult con segmentos clasificados y linaje inicializado
+ *
+ * @throws {SegmentationError} Si la segmentación falla
+ *
+ * @example
+ * ```typescript
+ * const result = segment({
+ *   content: 'Hello\nWorld',
+ *   source: 'UI',
+ *   metadata: {}
+ * })
+ *
+ * // result.segments contiene 2 segmentos, cada uno con:
+ * // - content original
+ * // - trust level clasificado
+ * // - lineage inicializado
+ * ```
+ */
+export declare function segment(input: CSLInput): CSLResult;
+//# sourceMappingURL=segment.d.ts.map

package/dist/csl/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../src/csl/segment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAc,MAAM,SAAS,CAAA;AAM9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CA4DlD"}