@astrale-os/kernel-core 0.4.1

package/dist/auth/expression/dedup.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Structural Deduplication for Identity Expressions
+ *
+ * Finds repeated subtrees in an expression and replaces them with references.
+ * Format-agnostic - works with JSON compact or binary encoding.
+ *
+ * ## When to use
+ *
+ * - Call `hasRepeatedSubtrees(expr)` first — returns true if dedup will help
+ * - Typical savings: 30-80% for expressions with shared subtrees
+ * - No benefit (~2% overhead) for expressions without duplicates
+ * - Best combined with binary encoding via `getCodec('binary', { dedup: true })`
+ *
+ * ## Activation
+ *
+ * ```typescript
+ * // Via codec directly:
+ * const codec = getCodec('binary', { dedup: true })
+ * const encoded = codec.encodeExpr(expr)  // auto-dedup if repeated subtrees found
+ * ```
+ *
+ * ## Pipeline
+ *
+ * ```
+ * Encode: expr → dedup() → DedupedExpr → encode() → bytes → base64
+ * Decode: base64 → bytes → decode() → DedupedExpr → expand() → IdentityExpr
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const shared = union(identity("A"), identity("B")).build()
+ * const expr = intersect(raw(shared), exclude(raw(shared), identity("C"))).build()
+ *
+ * const deduped = dedup(expr)
+ * // deduped.defs = [{ kind: 'union', operands: [{id: 'A'}, {id: 'B'}] }]
+ * // deduped.root = { kind: 'intersect', operands: [{ $ref: 0 }, ...] }
+ *
+ * const original = expand(deduped)
+ * // Back to full expression
+ * ```
+ */
+import type { IdentityId } from '#ids';
+import type { IdentityExpr, Scope } from './types';
+/**
+ * Reference to a definition in DedupedExpr.defs.
+ */
+export type Ref = {
+    $ref: number;
+};
+/**
+ * Expression node that may contain references.
+ */
+export type RefExpr = Ref | {
+    kind: 'identity';
+    id: IdentityId;
+} | {
+    kind: 'scope';
+    scopes: Scope[];
+    expr: RefExpr;
+} | {
+    kind: 'union';
+    operands: RefExpr[];
+} | {
+    kind: 'intersect';
+    operands: RefExpr[];
+} | {
+    kind: 'exclude';
+    base: RefExpr;
+    excluded: RefExpr[];
+};
+/**
+ * Deduplicated expression with shared definitions extracted.
+ */
+export type DedupedExpr = {
+    defs: IdentityExpr[];
+    root: RefExpr;
+};
+/**
+ * Type guard to check if a value is a Ref.
+ */
+export declare function isRef(value: unknown): value is Ref;
+/**
+ * Type guard to check if a value is a DedupedExpr.
+ */
+export declare function isDedupedExpr(value: unknown): value is DedupedExpr;
+/**
+ * Deduplicate an expression by extracting repeated subtrees.
+ *
+ * Only subtrees that appear 2+ times are extracted.
+ * Prioritizes larger subtrees (processed largest-first).
+ *
+ * @param expr - The expression to deduplicate
+ * @returns Deduplicated expression with shared definitions
+ */
+export declare function dedup(expr: IdentityExpr): DedupedExpr;
+/**
+ * Expand a deduplicated expression back to full form.
+ *
+ * @param deduped - Deduplicated expression with refs
+ * @returns Full IdentityExpr with refs resolved
+ */
+export declare function expand(deduped: DedupedExpr): IdentityExpr;
+/**
+ * Check if an expression has repeated subtrees (dedup would help).
+ *
+ * @param expr - Expression to check
+ * @returns true if there are duplicate subtrees
+ */
+export declare function hasRepeatedSubtrees(expr: IdentityExpr): boolean;
+/**
+ * Get statistics about potential deduplication.
+ *
+ * @param expr - Expression to analyze
+ * @returns Stats about repeated subtrees
+ */
+export declare function dedupStats(expr: IdentityExpr): {
+    totalSubtrees: number;
+    uniqueSubtrees: number;
+    duplicateSubtrees: number;
+    potentialSavings: number;
+};
+//# sourceMappingURL=dedup.d.ts.map

package/dist/auth/expression/dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.d.ts","sourceRoot":"","sources":["../../../auth/expression/dedup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAEtC,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAMlD;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAElC;;GAEG;AACH,MAAM,MAAM,OAAO,GACf,GAAG,GACH;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,UAAU,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;CAAE,CAAA;AAE3D;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,YAAY,EAAE,CAAA;IACpB,IAAI,EAAE,OAAO,CAAA;CACd,CAAA;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CASlD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAQlE;AAiHD;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,CAqCrD;AA0CD;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,YAAY,CAEzD;AAMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAU/D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG;IAC9C,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;IACzB,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAoBA"}

package/dist/auth/expression/dedup.js

@@ -0,0 +1,290 @@
+/**
+ * Structural Deduplication for Identity Expressions
+ *
+ * Finds repeated subtrees in an expression and replaces them with references.
+ * Format-agnostic - works with JSON compact or binary encoding.
+ *
+ * ## When to use
+ *
+ * - Call `hasRepeatedSubtrees(expr)` first — returns true if dedup will help
+ * - Typical savings: 30-80% for expressions with shared subtrees
+ * - No benefit (~2% overhead) for expressions without duplicates
+ * - Best combined with binary encoding via `getCodec('binary', { dedup: true })`
+ *
+ * ## Activation
+ *
+ * ```typescript
+ * // Via codec directly:
+ * const codec = getCodec('binary', { dedup: true })
+ * const encoded = codec.encodeExpr(expr)  // auto-dedup if repeated subtrees found
+ * ```
+ *
+ * ## Pipeline
+ *
+ * ```
+ * Encode: expr → dedup() → DedupedExpr → encode() → bytes → base64
+ * Decode: base64 → bytes → decode() → DedupedExpr → expand() → IdentityExpr
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const shared = union(identity("A"), identity("B")).build()
+ * const expr = intersect(raw(shared), exclude(raw(shared), identity("C"))).build()
+ *
+ * const deduped = dedup(expr)
+ * // deduped.defs = [{ kind: 'union', operands: [{id: 'A'}, {id: 'B'}] }]
+ * // deduped.root = { kind: 'intersect', operands: [{ $ref: 0 }, ...] }
+ *
+ * const original = expand(deduped)
+ * // Back to full expression
+ * ```
+ */
+/**
+ * Type guard to check if a value is a Ref.
+ */
+export function isRef(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$ref' in value &&
+        typeof value.$ref === 'number' &&
+        Number.isInteger(value.$ref) &&
+        value.$ref >= 0);
+}
+/**
+ * Type guard to check if a value is a DedupedExpr.
+ */
+export function isDedupedExpr(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'defs' in value &&
+        'root' in value &&
+        Array.isArray(value.defs));
+}
+// =============================================================================
+// HASHING
+// =============================================================================
+/**
+ * Compute a deterministic hash of an expression for duplicate detection.
+ * Uses length-prefixed IDs to avoid false substring matches.
+ * e.g., identity("A") -> "i[1]:A" vs identity("AB") -> "i[2]:AB"
+ */
+function hashExpr(expr) {
+    switch (expr.kind) {
+        case 'identity':
+            return `i[${expr.id.length}]:${expr.id}`;
+        case 'scope':
+            return `s:${JSON.stringify(expr.scopes)}:(${hashExpr(expr.expr)})`;
+        case 'union':
+            return `u:(${expr.operands.map(hashExpr).join('|')})`;
+        case 'intersect':
+            return `n:(${expr.operands.map(hashExpr).join('|')})`;
+        case 'exclude':
+            return `x:(${hashExpr(expr.base)}):(${expr.excluded.map(hashExpr).join('|')})`;
+    }
+}
+// =============================================================================
+// DEDUPLICATION
+// =============================================================================
+/**
+ * Collect hashes of all direct children of an expression.
+ */
+function collectChildHashes(expr) {
+    switch (expr.kind) {
+        case 'identity':
+            return [];
+        case 'scope':
+            return [expr.expr];
+        case 'union':
+        case 'intersect':
+            return expr.operands;
+        case 'exclude':
+            return [expr.base, ...expr.excluded];
+    }
+}
+/**
+ * Count occurrences of each subtree hash in the expression.
+ * Returns the set of all child hashes (for nesting detection).
+ */
+function countSubtrees(expr, counts) {
+    const hash = hashExpr(expr);
+    const existing = counts.get(hash);
+    // Collect child hashes by recursing first
+    const childHashes = new Set();
+    const children = collectChildHashes(expr);
+    for (const child of children) {
+        const descendantHashes = countSubtrees(child, counts);
+        const childHash = hashExpr(child);
+        childHashes.add(childHash);
+        for (const h of descendantHashes) {
+            childHashes.add(h);
+        }
+    }
+    if (existing) {
+        existing.count++;
+    }
+    else {
+        counts.set(hash, { count: 1, expr, childHashes });
+    }
+    return childHashes;
+}
+/**
+ * Replace duplicate subtrees with references.
+ */
+function replaceWithRefs(expr, hashToRef) {
+    const hash = hashExpr(expr);
+    const refIndex = hashToRef.get(hash);
+    // If this subtree is in defs, return a reference
+    if (refIndex !== undefined) {
+        return { $ref: refIndex };
+    }
+    switch (expr.kind) {
+        case 'identity':
+            return expr;
+        case 'scope':
+            return { kind: 'scope', scopes: expr.scopes, expr: replaceWithRefs(expr.expr, hashToRef) };
+        case 'union':
+            return { kind: 'union', operands: expr.operands.map((op) => replaceWithRefs(op, hashToRef)) };
+        case 'intersect':
+            return {
+                kind: 'intersect',
+                operands: expr.operands.map((op) => replaceWithRefs(op, hashToRef)),
+            };
+        case 'exclude':
+            return {
+                kind: 'exclude',
+                base: replaceWithRefs(expr.base, hashToRef),
+                excluded: expr.excluded.map((ex) => replaceWithRefs(ex, hashToRef)),
+            };
+    }
+}
+/**
+ * Deduplicate an expression by extracting repeated subtrees.
+ *
+ * Only subtrees that appear 2+ times are extracted.
+ * Prioritizes larger subtrees (processed largest-first).
+ *
+ * @param expr - The expression to deduplicate
+ * @returns Deduplicated expression with shared definitions
+ */
+export function dedup(expr) {
+    // Step 1: Count all subtree occurrences (also tracks child relationships)
+    const counts = new Map();
+    countSubtrees(expr, counts);
+    // Step 2: Find subtrees that appear 2+ times
+    // Sort by hash length descending to prioritize larger subtrees
+    const duplicates = Array.from(counts.entries())
+        .filter(([_, { count }]) => count >= 2)
+        .sort((a, b) => b[0].length - a[0].length);
+    // Step 3: Build defs array and hash→ref mapping
+    // Skip subtrees that are children of already-included subtrees
+    const defs = [];
+    const hashToRef = new Map();
+    for (const [hash, { expr: subtree }] of duplicates) {
+        // Skip if this subtree is a child of an already-included subtree
+        // (parent already includes this, so extracting separately is redundant)
+        let isChildOfIncluded = false;
+        for (const [includedHash, includedData] of counts) {
+            if (hashToRef.has(includedHash) && includedData.childHashes.has(hash)) {
+                isChildOfIncluded = true;
+                break;
+            }
+        }
+        if (!isChildOfIncluded) {
+            hashToRef.set(hash, defs.length);
+            defs.push(subtree);
+        }
+    }
+    // Step 4: Replace duplicates with refs in the tree
+    const root = replaceWithRefs(expr, hashToRef);
+    return { defs, root };
+}
+// =============================================================================
+// EXPANSION
+// =============================================================================
+/**
+ * Expand a RefExpr back to a full IdentityExpr.
+ */
+function expandRefExpr(refExpr, defs) {
+    if (isRef(refExpr)) {
+        const def = defs[refExpr.$ref];
+        if (!def) {
+            throw new Error(`Invalid reference: $ref ${refExpr.$ref} not found in defs`);
+        }
+        return def;
+    }
+    switch (refExpr.kind) {
+        case 'identity':
+            return { kind: 'identity', id: refExpr.id };
+        case 'scope':
+            return { kind: 'scope', scopes: refExpr.scopes, expr: expandRefExpr(refExpr.expr, defs) };
+        case 'union':
+            return {
+                kind: 'union',
+                operands: refExpr.operands.map((op) => expandRefExpr(op, defs)),
+            };
+        case 'intersect':
+            return {
+                kind: 'intersect',
+                operands: refExpr.operands.map((op) => expandRefExpr(op, defs)),
+            };
+        case 'exclude':
+            return {
+                kind: 'exclude',
+                base: expandRefExpr(refExpr.base, defs),
+                excluded: refExpr.excluded.map((ex) => expandRefExpr(ex, defs)),
+            };
+    }
+}
+/**
+ * Expand a deduplicated expression back to full form.
+ *
+ * @param deduped - Deduplicated expression with refs
+ * @returns Full IdentityExpr with refs resolved
+ */
+export function expand(deduped) {
+    return expandRefExpr(deduped.root, deduped.defs);
+}
+// =============================================================================
+// UTILITIES
+// =============================================================================
+/**
+ * Check if an expression has repeated subtrees (dedup would help).
+ *
+ * @param expr - Expression to check
+ * @returns true if there are duplicate subtrees
+ */
+export function hasRepeatedSubtrees(expr) {
+    const counts = new Map();
+    countSubtrees(expr, counts);
+    for (const { count } of counts.values()) {
+        if (count >= 2) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get statistics about potential deduplication.
+ *
+ * @param expr - Expression to analyze
+ * @returns Stats about repeated subtrees
+ */
+export function dedupStats(expr) {
+    const counts = new Map();
+    countSubtrees(expr, counts);
+    let totalSubtrees = 0;
+    let duplicateSubtrees = 0;
+    for (const { count } of counts.values()) {
+        totalSubtrees += count;
+        if (count >= 2) {
+            duplicateSubtrees += count - 1; // All but first occurrence
+        }
+    }
+    return {
+        totalSubtrees,
+        uniqueSubtrees: counts.size,
+        duplicateSubtrees,
+        potentialSavings: totalSubtrees > 0 ? Math.round((duplicateSubtrees / totalSubtrees) * 100) : 0,
+    };
+}
+//# sourceMappingURL=dedup.js.map

package/dist/auth/expression/dedup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.js","sourceRoot":"","sources":["../../../auth/expression/dedup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAkCH;;GAEG;AACH,MAAM,UAAU,KAAK,CAAC,KAAc;IAClC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACf,OAAQ,KAAa,CAAC,IAAI,KAAK,QAAQ;QACvC,MAAM,CAAC,SAAS,CAAE,KAAa,CAAC,IAAI,CAAC;QACpC,KAAa,CAAC,IAAI,IAAI,CAAC,CACzB,CAAA;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACf,MAAM,IAAI,KAAK;QACf,KAAK,CAAC,OAAO,CAAE,KAAqB,CAAC,IAAI,CAAC,CAC3C,CAAA;AACH,CAAC;AAED,gFAAgF;AAChF,UAAU;AACV,gFAAgF;AAEhF;;;;GAIG;AACH,SAAS,QAAQ,CAAC,IAAkB;IAClC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,UAAU;YACb,OAAO,KAAK,IAAI,CAAC,EAAE,CAAC,MAAM,KAAK,IAAI,CAAC,EAAE,EAAE,CAAA;QAC1C,KAAK,OAAO;YACV,OAAO,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;QACpE,KAAK,OAAO;YACV,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;QACvD,KAAK,WAAW;YACd,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;QACvD,KAAK,SAAS;YACZ,OAAO,MAAM,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;IAClF,CAAC;AACH,CAAC;AAED,gFAAgF;AAChF,gBAAgB;AAChB,gFAAgF;AAEhF;;GAEG;AACH,SAAS,kBAAkB,CAAC,IAAkB;IAC5C,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,UAAU;YACb,OAAO,EAAE,CAAA;QACX,KAAK,OAAO;YACV,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACpB,KAAK,OAAO,CAAC;QACb,KAAK,WAAW;YACd,OAAO,IAAI,CAAC,QAAQ,CAAA;QACtB,KAAK,SAAS;YACZ,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAA;IACxC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CACpB,IAAkB,EAClB,MAAoF;IAEpF,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC3B,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAEjC,0CAA0C;IAC1C,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAA;IACrC,MAAM,QAAQ,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAA;IAEzC,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,gBAAgB,GAAG,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QACrD,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;QACjC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;QAC1B,KAAK,MAAM,CAAC,IAAI,gBAAgB,EAAE,CAAC;YACjC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QACpB,CAAC;IACH,CAAC;IAED,IAAI,QAAQ,EAAE,CAAC;QACb,QAAQ,CAAC,KAAK,EAAE,CAAA;IAClB,CAAC;SAAM,CAAC;QACN,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAA;IACnD,CAAC;IAED,OAAO,WAAW,CAAA;AACpB,CAAC;AAED;;GAEG;AACH,SAAS,eAAe,CAAC,IAAkB,EAAE,SAA8B;IACzE,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC3B,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAEpC,iDAAiD;IACjD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;IAC3B,CAAC;IAED,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,UAAU;YACb,OAAO,IAAI,CAAA;QACb,KAAK,OAAO;YACV,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,CAAA;QAC5F,KAAK,OAAO;YACV,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,EAAE,CAAA;QAC/F,KAAK,WAAW;YACd,OAAO;gBACL,IAAI,EAAE,WAAW;gBACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;aACpE,CAAA;QACH,KAAK,SAAS;YACZ,OAAO;gBACL,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC;gBAC3C,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;aACpE,CAAA;IACL,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,KAAK,CAAC,IAAkB;IACtC,0EAA0E;IAC1E,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2E,CAAA;IACjG,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAE3B,6CAA6C;IAC7C,+DAA+D;IAC/D,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;SAC5C,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC;SACtC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;IAE5C,gDAAgD;IAChD,+DAA+D;IAC/D,MAAM,IAAI,GAAmB,EAAE,CAAA;IAC/B,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAA;IAE3C,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC;QACnD,iEAAiE;QACjE,wEAAwE;QACxE,IAAI,iBAAiB,GAAG,KAAK,CAAA;QAC7B,KAAK,MAAM,CAAC,YAAY,EAAE,YAAY,CAAC,IAAI,MAAM,EAAE,CAAC;YAClD,IAAI,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACtE,iBAAiB,GAAG,IAAI,CAAA;gBACxB,MAAK;YACP,CAAC;QACH,CAAC;QAED,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;YAChC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACpB,CAAC;IACH,CAAC;IAED,mDAAmD;IACnD,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAE7C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;AACvB,CAAC;AAED,gFAAgF;AAChF,YAAY;AACZ,gFAAgF;AAEhF;;GAEG;AACH,SAAS,aAAa,CAAC,OAAgB,EAAE,IAAoB;IAC3D,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAC9B,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,CAAC,IAAI,oBAAoB,CAAC,CAAA;QAC9E,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;QACrB,KAAK,UAAU;YACb,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,OAAO,CAAC,EAAgB,EAAE,CAAA;QAC3D,KAAK,OAAO;YACV,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAA;QAC3F,KAAK,OAAO;YACV,OAAO;gBACL,IAAI,EAAE,OAAO;gBACb,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;aAChE,CAAA;QACH,KAAK,WAAW;YACd,OAAO;gBACL,IAAI,EAAE,WAAW;gBACjB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;aAChE,CAAA;QACH,KAAK,SAAS;YACZ,OAAO;gBACL,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC;gBACvC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,aAAa,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;aAChE,CAAA;IACL,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,OAAoB;IACzC,OAAO,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;AAClD,CAAC;AAED,gFAAgF;AAChF,YAAY;AACZ,gFAAgF;AAEhF;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAkB;IACpD,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2E,CAAA;IACjG,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAE3B,KAAK,MAAM,EAAE,KAAK,EAAE,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QACxC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,OAAO,IAAI,CAAA;QACb,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,IAAkB;IAM3C,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2E,CAAA;IACjG,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAE3B,IAAI,aAAa,GAAG,CAAC,CAAA;IACrB,IAAI,iBAAiB,GAAG,CAAC,CAAA;IAEzB,KAAK,MAAM,EAAE,KAAK,EAAE,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;QACxC,aAAa,IAAI,KAAK,CAAA;QACtB,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,iBAAiB,IAAI,KAAK,GAAG,CAAC,CAAA,CAAC,2BAA2B;QAC5D,CAAC;IACH,CAAC;IAED,OAAO;QACL,aAAa;QACb,cAAc,EAAE,MAAM,CAAC,IAAI;QAC3B,iBAAiB;QACjB,gBAAgB,EAAE,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,iBAAiB,GAAG,aAAa,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;KAChG,CAAA;AACH,CAAC"}

package/dist/auth/expression/encoding.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Binary Varint Encoding for Identity Expressions
+ *
+ * Zero-dependency binary encoding for maximum compression.
+ *
+ * Type Tags:
+ * - 0x01 = Identity
+ * - 0x03 = Scope
+ * - 0x10 = Union
+ * - 0x11 = Intersect
+ * - 0x12 = Exclude
+ * - 0x20 = Reference (for deduped expressions)
+ * - 0x30 = Deduped wrapper (defs + root)
+ *
+ * Union/Intersect: TAG + varint(operand count) + operands
+ * Exclude: TAG + base + varint(excluded count) + excluded operands
+ * Scope: TAG + varint(scope count) + scopes + inner expr
+ */
+import type { IdentityExpr } from './types';
+import { type DedupedExpr } from './dedup';
+export declare function encode(expr: IdentityExpr | DedupedExpr): Uint8Array;
+export declare function decode(bytes: Uint8Array): IdentityExpr | DedupedExpr;
+export declare function encodeBase64(expr: IdentityExpr | DedupedExpr): string;
+export declare function decodeBase64(base64: string): IdentityExpr | DedupedExpr;
+export declare function compareSizes(expr: IdentityExpr): {
+    verbose: number;
+    compact: number;
+    binary: number;
+    binaryBase64: number;
+};
+//# sourceMappingURL=encoding.d.ts.map

package/dist/auth/expression/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../../auth/expression/encoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAS,MAAM,SAAS,CAAA;AAIlD,OAAO,EAAwB,KAAK,WAAW,EAAgB,MAAM,SAAS,CAAA;AAgU9E,wBAAgB,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,GAAG,UAAU,CAUnE;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,GAAG,WAAW,CAsBpE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,GAAG,MAAM,CAOrE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,WAAW,CAOvE;AAMD,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG;IAChD,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;CACrB,CAOA"}