@kya-os/contracts 1.3.2 → 1.3.3

package/dist/tlkrc/rotation.d.ts

@@ -1,44 +1,17 @@
-/**
- * TLKRC (Transparent Log Key Rotation Contract)
- *
- * Types for key rotation events in a transparent, auditable manner
- *
- * Related Spec: MCP-I Core
- * Python Reference: Core-Documentation.md
- */
 import { z } from 'zod';
-/**
- * Rotation Event Schema
- *
- * Represents a key rotation event in a transparent log.
- * Events form a hash-linked chain for auditability.
- *
- * **Dual-Key Grace Window:**
- * During rotation, both `prevKeyId` and `nextKeyId` are valid
- * from `effectiveAt` until `effectiveAt + grace period`.
- */
 export declare const RotationEventSchema: z.ZodEffects<z.ZodObject<{
-    /** DID of the issuer performing the rotation */
     issuerDid: z.ZodString;
-    /** Previous key ID being rotated out */
     prevKeyId: z.ZodString;
-    /** New key ID being rotated in */
     nextKeyId: z.ZodString;
-    /** Timestamp when new key becomes effective (Unix seconds) */
     effectiveAt: z.ZodNumber;
-    /** Timestamp when event was issued (Unix seconds) */
     issuedAt: z.ZodNumber;
-    /** Sequence number (monotonically increasing) */
     seq: z.ZodNumber;
-    /** Hash of previous rotation event (null for first rotation) */
     prevEventHash: z.ZodOptional<z.ZodString>;
-    /** Signature over the event (using prevKeyId) */
     signature: z.ZodString;
-    /** Optional metadata */
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, "strip", z.ZodTypeAny, {
-    issuerDid: string;
     signature: string;
+    issuerDid: string;
     prevKeyId: string;
     nextKeyId: string;
     effectiveAt: number;
@@ -47,8 +20,8 @@ export declare const RotationEventSchema: z.ZodEffects<z.ZodObject<{
     metadata?: Record<string, any> | undefined;
     prevEventHash?: string | undefined;
 }, {
-    issuerDid: string;
     signature: string;
+    issuerDid: string;
     prevKeyId: string;
     nextKeyId: string;
     effectiveAt: number;
@@ -57,8 +30,8 @@ export declare const RotationEventSchema: z.ZodEffects<z.ZodObject<{
     metadata?: Record<string, any> | undefined;
     prevEventHash?: string | undefined;
 }>, {
-    issuerDid: string;
     signature: string;
+    issuerDid: string;
     prevKeyId: string;
     nextKeyId: string;
     effectiveAt: number;
@@ -67,8 +40,8 @@ export declare const RotationEventSchema: z.ZodEffects<z.ZodObject<{
     metadata?: Record<string, any> | undefined;
     prevEventHash?: string | undefined;
 }, {
-    issuerDid: string;
     signature: string;
+    issuerDid: string;
     prevKeyId: string;
     nextKeyId: string;
     effectiveAt: number;
@@ -78,37 +51,21 @@ export declare const RotationEventSchema: z.ZodEffects<z.ZodObject<{
     prevEventHash?: string | undefined;
 }>;
 export type RotationEvent = z.infer<typeof RotationEventSchema>;
-/**
- * Rotation Chain
- *
- * Represents a chain of rotation events
- */
 export declare const RotationChainSchema: z.ZodObject<{
-    /** Issuer DID */
     issuerDid: z.ZodString;
-    /** All rotation events in order */
     events: z.ZodArray<z.ZodEffects<z.ZodObject<{
-        /** DID of the issuer performing the rotation */
         issuerDid: z.ZodString;
-        /** Previous key ID being rotated out */
         prevKeyId: z.ZodString;
-        /** New key ID being rotated in */
         nextKeyId: z.ZodString;
-        /** Timestamp when new key becomes effective (Unix seconds) */
         effectiveAt: z.ZodNumber;
-        /** Timestamp when event was issued (Unix seconds) */
         issuedAt: z.ZodNumber;
-        /** Sequence number (monotonically increasing) */
         seq: z.ZodNumber;
-        /** Hash of previous rotation event (null for first rotation) */
         prevEventHash: z.ZodOptional<z.ZodString>;
-        /** Signature over the event (using prevKeyId) */
         signature: z.ZodString;
-        /** Optional metadata */
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, "strip", z.ZodTypeAny, {
-        issuerDid: string;
         signature: string;
+        issuerDid: string;
         prevKeyId: string;
         nextKeyId: string;
         effectiveAt: number;
@@ -117,8 +74,8 @@ export declare const RotationChainSchema: z.ZodObject<{
         metadata?: Record<string, any> | undefined;
         prevEventHash?: string | undefined;
     }, {
-        issuerDid: string;
         signature: string;
+        issuerDid: string;
         prevKeyId: string;
         nextKeyId: string;
         effectiveAt: number;
@@ -127,8 +84,8 @@ export declare const RotationChainSchema: z.ZodObject<{
         metadata?: Record<string, any> | undefined;
         prevEventHash?: string | undefined;
     }>, {
-        issuerDid: string;
         signature: string;
+        issuerDid: string;
         prevKeyId: string;
         nextKeyId: string;
         effectiveAt: number;
@@ -137,8 +94,8 @@ export declare const RotationChainSchema: z.ZodObject<{
         metadata?: Record<string, any> | undefined;
         prevEventHash?: string | undefined;
     }, {
-        issuerDid: string;
         signature: string;
+        issuerDid: string;
         prevKeyId: string;
         nextKeyId: string;
         effectiveAt: number;
@@ -147,18 +104,15 @@ export declare const RotationChainSchema: z.ZodObject<{
         metadata?: Record<string, any> | undefined;
         prevEventHash?: string | undefined;
     }>, "many">;
-    /** Current active key ID */
     currentKeyId: z.ZodString;
-    /** Whether chain is valid */
     valid: z.ZodBoolean;
-    /** Optional validation errors */
     errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     valid: boolean;
     issuerDid: string;
     events: {
-        issuerDid: string;
         signature: string;
+        issuerDid: string;
         prevKeyId: string;
         nextKeyId: string;
         effectiveAt: number;
@@ -173,8 +127,8 @@ export declare const RotationChainSchema: z.ZodObject<{
     valid: boolean;
     issuerDid: string;
     events: {
-        issuerDid: string;
         signature: string;
+        issuerDid: string;
         prevKeyId: string;
         nextKeyId: string;
         effectiveAt: number;
@@ -187,18 +141,9 @@ export declare const RotationChainSchema: z.ZodObject<{
     errors?: string[] | undefined;
 }>;
 export type RotationChain = z.infer<typeof RotationChainSchema>;
-/**
- * Validation Helpers
- */
-/**
- * Validate a rotation event
- *
- * @param event - The event to validate
- * @returns Validation result
- */
 export declare function validateRotationEvent(event: unknown): z.SafeParseReturnType<{
-    issuerDid: string;
     signature: string;
+    issuerDid: string;
     prevKeyId: string;
     nextKeyId: string;
     effectiveAt: number;
@@ -207,8 +152,8 @@ export declare function validateRotationEvent(event: unknown): z.SafeParseReturn
     metadata?: Record<string, any> | undefined;
     prevEventHash?: string | undefined;
 }, {
-    issuerDid: string;
     signature: string;
+    issuerDid: string;
     prevKeyId: string;
     nextKeyId: string;
     effectiveAt: number;
@@ -217,30 +162,7 @@ export declare function validateRotationEvent(event: unknown): z.SafeParseReturn
     metadata?: Record<string, any> | undefined;
     prevEventHash?: string | undefined;
 }>;
-/**
- * Validate rotation chain integrity
- *
- * @param chain - The chain to validate
- * @returns true if chain is valid
- */
 export declare function isRotationChainValid(chain: RotationChain): boolean;
-/**
- * Get active key at a specific timestamp
- *
- * @param chain - The rotation chain
- * @param timestamp - Timestamp in seconds
- * @returns Active key ID at that time, or null if none
- */
 export declare function getActiveKeyAt(chain: RotationChain, timestamp: number): string | null;
-/**
- * Constants
- */
-/**
- * Default grace period for dual-key validity (24 hours)
- */
 export declare const DEFAULT_GRACE_PERIOD_SEC: number;
-/**
- * Maximum reasonable grace period (30 days)
- */
 export declare const MAX_GRACE_PERIOD_SEC: number;
-//# sourceMappingURL=rotation.d.ts.map

package/dist/tlkrc/rotation.js

@@ -1,90 +1,37 @@
 "use strict";
-/**
- * TLKRC (Transparent Log Key Rotation Contract)
- *
- * Types for key rotation events in a transparent, auditable manner
- *
- * Related Spec: MCP-I Core
- * Python Reference: Core-Documentation.md
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_GRACE_PERIOD_SEC = exports.DEFAULT_GRACE_PERIOD_SEC = exports.RotationChainSchema = exports.RotationEventSchema = void 0;
 exports.validateRotationEvent = validateRotationEvent;
 exports.isRotationChainValid = isRotationChainValid;
 exports.getActiveKeyAt = getActiveKeyAt;
 const zod_1 = require("zod");
-/**
- * Rotation Event Schema
- *
- * Represents a key rotation event in a transparent log.
- * Events form a hash-linked chain for auditability.
- *
- * **Dual-Key Grace Window:**
- * During rotation, both `prevKeyId` and `nextKeyId` are valid
- * from `effectiveAt` until `effectiveAt + grace period`.
- */
 exports.RotationEventSchema = zod_1.z.object({
-    /** DID of the issuer performing the rotation */
     issuerDid: zod_1.z.string().min(1),
-    /** Previous key ID being rotated out */
     prevKeyId: zod_1.z.string().min(1),
-    /** New key ID being rotated in */
     nextKeyId: zod_1.z.string().min(1),
-    /** Timestamp when new key becomes effective (Unix seconds) */
     effectiveAt: zod_1.z.number().int().positive(),
-    /** Timestamp when event was issued (Unix seconds) */
     issuedAt: zod_1.z.number().int().positive(),
-    /** Sequence number (monotonically increasing) */
     seq: zod_1.z.number().int().nonnegative(),
-    /** Hash of previous rotation event (null for first rotation) */
     prevEventHash: zod_1.z.string().optional(),
-    /** Signature over the event (using prevKeyId) */
     signature: zod_1.z.string().min(1),
-    /** Optional metadata */
     metadata: zod_1.z.record(zod_1.z.any()).optional(),
 }).refine((event) => event.effectiveAt >= event.issuedAt, {
     message: 'effectiveAt must be >= issuedAt',
 });
-/**
- * Rotation Chain
- *
- * Represents a chain of rotation events
- */
 exports.RotationChainSchema = zod_1.z.object({
-    /** Issuer DID */
     issuerDid: zod_1.z.string().min(1),
-    /** All rotation events in order */
     events: zod_1.z.array(exports.RotationEventSchema).min(1),
-    /** Current active key ID */
     currentKeyId: zod_1.z.string().min(1),
-    /** Whether chain is valid */
     valid: zod_1.z.boolean(),
-    /** Optional validation errors */
     errors: zod_1.z.array(zod_1.z.string()).optional(),
 });
-/**
- * Validation Helpers
- */
-/**
- * Validate a rotation event
- *
- * @param event - The event to validate
- * @returns Validation result
- */
 function validateRotationEvent(event) {
     return exports.RotationEventSchema.safeParse(event);
 }
-/**
- * Validate rotation chain integrity
- *
- * @param chain - The chain to validate
- * @returns true if chain is valid
- */
 function isRotationChainValid(chain) {
     if (chain.events.length === 0) {
         return false;
     }
-    // Check sequence numbers are monotonic
     for (let i = 1; i < chain.events.length; i++) {
         if (chain.events[i].seq <= chain.events[i - 1].seq) {
             return false;
@@ -92,36 +39,17 @@ function isRotationChainValid(chain) {
     }
     return chain.valid;
 }
-/**
- * Get active key at a specific timestamp
- *
- * @param chain - The rotation chain
- * @param timestamp - Timestamp in seconds
- * @returns Active key ID at that time, or null if none
- */
 function getActiveKeyAt(chain, timestamp) {
     if (chain.events.length === 0) {
         return null;
     }
-    // Find the most recent event that's effective at the timestamp
     for (let i = chain.events.length - 1; i >= 0; i--) {
         const event = chain.events[i];
         if (event.effectiveAt <= timestamp) {
             return event.nextKeyId;
         }
     }
-    // If no event is effective yet, use the initial key
     return chain.events[0].prevKeyId;
 }
-/**
- * Constants
- */
-/**
- * Default grace period for dual-key validity (24 hours)
- */
 exports.DEFAULT_GRACE_PERIOD_SEC = 24 * 60 * 60;
-/**
- * Maximum reasonable grace period (30 days)
- */
 exports.MAX_GRACE_PERIOD_SEC = 30 * 24 * 60 * 60;
-//# sourceMappingURL=rotation.js.map

package/dist/tool-protection/index.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+export interface ToolProtection {
+    requiresDelegation: boolean;
+    requiredScopes: string[];
+    riskLevel?: 'low' | 'medium' | 'high' | 'critical';
+}
+export type ToolProtectionMap = Record<string, ToolProtection>;
+export interface ToolProtectionResponse {
+    toolProtections: ToolProtectionMap;
+    metadata?: {
+        lastUpdated?: string;
+        version?: string;
+        source?: string;
+    };
+}
+export interface DelegationRequiredErrorData {
+    toolName: string;
+    requiredScopes: string[];
+    consentUrl?: string;
+    authorizationUrl?: string;
+    reason?: string;
+}
+export declare const ToolProtectionSchema: z.ZodObject<{
+    requiresDelegation: z.ZodBoolean;
+    requiredScopes: z.ZodArray<z.ZodString, "many">;
+    riskLevel: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+}, "strip", z.ZodTypeAny, {
+    requiresDelegation: boolean;
+    requiredScopes: string[];
+    riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+}, {
+    requiresDelegation: boolean;
+    requiredScopes: string[];
+    riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+}>;
+export declare const ToolProtectionMapSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    requiresDelegation: z.ZodBoolean;
+    requiredScopes: z.ZodArray<z.ZodString, "many">;
+    riskLevel: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+}, "strip", z.ZodTypeAny, {
+    requiresDelegation: boolean;
+    requiredScopes: string[];
+    riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+}, {
+    requiresDelegation: boolean;
+    requiredScopes: string[];
+    riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+}>>;
+export declare const ToolProtectionResponseSchema: z.ZodObject<{
+    toolProtections: z.ZodRecord<z.ZodString, z.ZodObject<{
+        requiresDelegation: z.ZodBoolean;
+        requiredScopes: z.ZodArray<z.ZodString, "many">;
+        riskLevel: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    }, "strip", z.ZodTypeAny, {
+        requiresDelegation: boolean;
+        requiredScopes: string[];
+        riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+    }, {
+        requiresDelegation: boolean;
+        requiredScopes: string[];
+        riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+    }>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        lastUpdated: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        version?: string | undefined;
+        lastUpdated?: string | undefined;
+        source?: string | undefined;
+    }, {
+        version?: string | undefined;
+        lastUpdated?: string | undefined;
+        source?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    toolProtections: Record<string, {
+        requiresDelegation: boolean;
+        requiredScopes: string[];
+        riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+    }>;
+    metadata?: {
+        version?: string | undefined;
+        lastUpdated?: string | undefined;
+        source?: string | undefined;
+    } | undefined;
+}, {
+    toolProtections: Record<string, {
+        requiresDelegation: boolean;
+        requiredScopes: string[];
+        riskLevel?: "low" | "medium" | "high" | "critical" | undefined;
+    }>;
+    metadata?: {
+        version?: string | undefined;
+        lastUpdated?: string | undefined;
+        source?: string | undefined;
+    } | undefined;
+}>;
+export declare const DelegationRequiredErrorDataSchema: z.ZodObject<{
+    toolName: z.ZodString;
+    requiredScopes: z.ZodArray<z.ZodString, "many">;
+    consentUrl: z.ZodOptional<z.ZodString>;
+    authorizationUrl: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    requiredScopes: string[];
+    toolName: string;
+    reason?: string | undefined;
+    consentUrl?: string | undefined;
+    authorizationUrl?: string | undefined;
+}, {
+    requiredScopes: string[];
+    toolName: string;
+    reason?: string | undefined;
+    consentUrl?: string | undefined;
+    authorizationUrl?: string | undefined;
+}>;
+export declare function isToolProtection(obj: any): obj is ToolProtection;
+export declare function isToolProtectionMap(obj: any): obj is ToolProtectionMap;
+export declare function isToolProtectionResponse(obj: any): obj is ToolProtectionResponse;
+export declare function isDelegationRequiredErrorData(obj: any): obj is DelegationRequiredErrorData;
+export declare function validateToolProtection(obj: any): ToolProtection;
+export declare function validateToolProtectionMap(obj: any): ToolProtectionMap;
+export declare function validateToolProtectionResponse(obj: any): ToolProtectionResponse;
+export declare function validateDelegationRequiredErrorData(obj: any): DelegationRequiredErrorData;
+export declare function toolRequiresDelegation(toolName: string, protections: ToolProtectionMap): boolean;
+export declare function getToolRequiredScopes(toolName: string, protections: ToolProtectionMap): string[];
+export declare function getToolRiskLevel(toolName: string, protections: ToolProtectionMap): ToolProtection['riskLevel'] | undefined;
+export declare function createDelegationRequiredError(toolName: string, requiredScopes: string[], consentUrl?: string): DelegationRequiredErrorData;

package/dist/tool-protection/index.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegationRequiredErrorDataSchema = exports.ToolProtectionResponseSchema = exports.ToolProtectionMapSchema = exports.ToolProtectionSchema = void 0;
+exports.isToolProtection = isToolProtection;
+exports.isToolProtectionMap = isToolProtectionMap;
+exports.isToolProtectionResponse = isToolProtectionResponse;
+exports.isDelegationRequiredErrorData = isDelegationRequiredErrorData;
+exports.validateToolProtection = validateToolProtection;
+exports.validateToolProtectionMap = validateToolProtectionMap;
+exports.validateToolProtectionResponse = validateToolProtectionResponse;
+exports.validateDelegationRequiredErrorData = validateDelegationRequiredErrorData;
+exports.toolRequiresDelegation = toolRequiresDelegation;
+exports.getToolRequiredScopes = getToolRequiredScopes;
+exports.getToolRiskLevel = getToolRiskLevel;
+exports.createDelegationRequiredError = createDelegationRequiredError;
+const zod_1 = require("zod");
+exports.ToolProtectionSchema = zod_1.z.object({
+    requiresDelegation: zod_1.z.boolean(),
+    requiredScopes: zod_1.z.array(zod_1.z.string()),
+    riskLevel: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional()
+});
+exports.ToolProtectionMapSchema = zod_1.z.record(zod_1.z.string(), exports.ToolProtectionSchema);
+exports.ToolProtectionResponseSchema = zod_1.z.object({
+    toolProtections: exports.ToolProtectionMapSchema,
+    metadata: zod_1.z.object({
+        lastUpdated: zod_1.z.string().optional(),
+        version: zod_1.z.string().optional(),
+        source: zod_1.z.string().optional()
+    }).optional()
+});
+exports.DelegationRequiredErrorDataSchema = zod_1.z.object({
+    toolName: zod_1.z.string(),
+    requiredScopes: zod_1.z.array(zod_1.z.string()),
+    consentUrl: zod_1.z.string().optional(),
+    authorizationUrl: zod_1.z.string().optional(),
+    reason: zod_1.z.string().optional()
+});
+function isToolProtection(obj) {
+    return exports.ToolProtectionSchema.safeParse(obj).success;
+}
+function isToolProtectionMap(obj) {
+    return exports.ToolProtectionMapSchema.safeParse(obj).success;
+}
+function isToolProtectionResponse(obj) {
+    return exports.ToolProtectionResponseSchema.safeParse(obj).success;
+}
+function isDelegationRequiredErrorData(obj) {
+    return exports.DelegationRequiredErrorDataSchema.safeParse(obj).success;
+}
+function validateToolProtection(obj) {
+    return exports.ToolProtectionSchema.parse(obj);
+}
+function validateToolProtectionMap(obj) {
+    return exports.ToolProtectionMapSchema.parse(obj);
+}
+function validateToolProtectionResponse(obj) {
+    return exports.ToolProtectionResponseSchema.parse(obj);
+}
+function validateDelegationRequiredErrorData(obj) {
+    return exports.DelegationRequiredErrorDataSchema.parse(obj);
+}
+function toolRequiresDelegation(toolName, protections) {
+    const protection = protections[toolName];
+    return protection?.requiresDelegation ?? false;
+}
+function getToolRequiredScopes(toolName, protections) {
+    const protection = protections[toolName];
+    return protection?.requiredScopes ?? [];
+}
+function getToolRiskLevel(toolName, protections) {
+    return protections[toolName]?.riskLevel;
+}
+function createDelegationRequiredError(toolName, requiredScopes, consentUrl) {
+    return {
+        toolName,
+        requiredScopes,
+        consentUrl,
+        authorizationUrl: consentUrl
+    };
+}

package/dist/utils/validation.d.ts

@@ -1,31 +1,14 @@
-/**
- * Shared validation utilities for mcpi packages
- * Consolidates common validation patterns to follow DRY principles
- */
 import { z } from "zod";
-/**
- * Generic validation result type
- */
 export interface ValidationResult<T = any> {
     valid: boolean;
     data?: T;
     errors: string[];
 }
-/**
- * Generic validation function with helpful error messages
- */
 export declare function validateInput<T>(schema: z.ZodSchema<T>, data: unknown, context?: string): ValidationResult<T>;
-/**
- * Validate object has required properties
- */
 export declare function hasRequiredProperties(obj: any, properties: string[], context?: string): ValidationResult;
-/**
- * Validate string format patterns
- */
 export declare const StringValidators: {
     did: (value: string) => boolean;
     kid: (value: string) => boolean;
     url: (value: string) => boolean;
     projectName: (value: string) => boolean;
 };
-//# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.js

@@ -1,15 +1,8 @@
 "use strict";
-/**
- * Shared validation utilities for mcpi packages
- * Consolidates common validation patterns to follow DRY principles
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringValidators = void 0;
 exports.validateInput = validateInput;
 exports.hasRequiredProperties = hasRequiredProperties;
-/**
- * Generic validation function with helpful error messages
- */
 function validateInput(schema, data, context) {
     const result = schema.safeParse(data);
     if (result.success) {
@@ -29,9 +22,6 @@ function validateInput(schema, data, context) {
         errors,
     };
 }
-/**
- * Validate object has required properties
- */
 function hasRequiredProperties(obj, properties, context) {
     if (typeof obj !== "object" || obj === null) {
         return {
@@ -50,9 +40,6 @@ function hasRequiredProperties(obj, properties, context) {
     }
     return { valid: true, errors: [] };
 }
-/**
- * Validate string format patterns
- */
 exports.StringValidators = {
     did: (value) => /^did:[a-z0-9]+:[a-zA-Z0-9._-]+$/.test(value),
     kid: (value) => /^[a-zA-Z0-9._-]+$/.test(value),
@@ -67,4 +54,3 @@ exports.StringValidators = {
     },
     projectName: (value) => /^[a-z0-9-]+$/.test(value) && value.length >= 1 && value.length <= 214,
 };
-//# sourceMappingURL=validation.js.map

package/dist/vc/index.d.ts

@@ -1,8 +1,2 @@
-/**
- * Verifiable Credentials Module Exports
- *
- * W3C Verifiable Credentials types, schemas, and utilities
- */
 export * from './schemas.js';
 export * from './statuslist.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/vc/index.js

@@ -1,9 +1,4 @@
 "use strict";
-/**
- * Verifiable Credentials Module Exports
- *
- * W3C Verifiable Credentials types, schemas, and utilities
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -21,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas.js"), exports);
 __exportStar(require("./statuslist.js"), exports);
-//# sourceMappingURL=index.js.map