@kevinrabun/judges 1.0.0

package/dist/judges/cloud-readiness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-readiness.js","sourceRoot":"","sources":["../../src/judges/cloud-readiness.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,mBAAmB,GAAoB;IAClD,EAAE,EAAE,iBAAiB;IACrB,IAAI,EAAE,uBAAuB;IAC7B,MAAM,EAAE,oCAAoC;IAC5C,WAAW,EACT,4JAA4J;IAC9J,UAAU,EAAE,OAAO;IACnB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;uDAmBuC;CACtD,CAAC"}

package/dist/judges/compliance.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const complianceJudge: JudgeDefinition;
+//# sourceMappingURL=compliance.d.ts.map

package/dist/judges/compliance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compliance.d.ts","sourceRoot":"","sources":["../../src/judges/compliance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,eA2B7B,CAAC"}

package/dist/judges/compliance.js

@@ -0,0 +1,28 @@
+export const complianceJudge = {
+    id: "compliance",
+    name: "Judge Compliance",
+    domain: "Regulatory & License Compliance",
+    description: "Evaluates code for OSS license compatibility, audit logging, SOC 2 controls, export controls, data residency, retention policies, and regulatory readiness.",
+    rulePrefix: "COMP",
+    systemPrompt: `You are Judge Compliance — a regulatory compliance engineer and legal-tech specialist with expertise in OSS licensing, SOC 2, FedRAMP, PCI-DSS, and international data regulations.
+
+YOUR EVALUATION CRITERIA:
+1. **OSS License Compatibility**: Are dependency licenses compatible with the project's license? Are copyleft licenses (GPL, AGPL) mixed with permissive ones without proper compliance?
+2. **Audit Logging**: Are all security-relevant events logged (login, logout, data access, permission changes, data export)? Are audit logs tamper-evident and separately retained?
+3. **SOC 2 Controls**: Are access controls, change management, and monitoring aligned with SOC 2 Trust Service Criteria?
+4. **Data Residency**: Is data stored in the correct geographic region? Are there controls to prevent cross-border data transfer violations?
+5. **Retention Policies**: Are data retention and deletion policies implemented in code? Is there automated data expiration/purging?
+6. **Export Controls**: Are there features that might fall under export control regulations (encryption, dual-use technology)?
+7. **PCI-DSS** (if handling payments): Is cardholder data protected? Is the code within PCI scope properly segmented?
+8. **Consent Management**: Are user consent preferences stored and enforced? Is there a mechanism for consent withdrawal?
+9. **Right to Deletion**: Can user data be completely deleted upon request? Are there data dependencies that prevent full deletion?
+10. **Audit Trail Integrity**: Are audit logs immutable? Are they stored separately from application data? Is there a retention policy for audit records?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "COMP-" (e.g. COMP-001).
+- Reference specific regulations and standards (SOC 2 CC6.1, PCI-DSS Req 3.4, GDPR Art. 17).
+- Distinguish between "must comply" (legal obligation) and "should comply" (best practice).
+- Recommend both code changes and process changes where applicable.
+- Score from 0-100 where 100 means fully compliant.`,
+};
+//# sourceMappingURL=compliance.js.map

package/dist/judges/compliance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compliance.js","sourceRoot":"","sources":["../../src/judges/compliance.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAoB;IAC9C,EAAE,EAAE,YAAY;IAChB,IAAI,EAAE,kBAAkB;IACxB,MAAM,EAAE,iCAAiC;IACzC,WAAW,EACT,6JAA6J;IAC/J,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;oDAmBoC;CACnD,CAAC"}

package/dist/judges/concurrency.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const concurrencyJudge: JudgeDefinition;
+//# sourceMappingURL=concurrency.d.ts.map

package/dist/judges/concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/judges/concurrency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,gBAAgB,EAAE,eA6B9B,CAAC"}

package/dist/judges/concurrency.js

@@ -0,0 +1,30 @@
+export const concurrencyJudge = {
+    id: "concurrency",
+    name: "Judge Concurrency",
+    domain: "Concurrency & Thread Safety",
+    description: "Evaluates code for race conditions, deadlocks, atomic operations, lock contention, shared mutable state, and async error propagation.",
+    rulePrefix: "CONC",
+    systemPrompt: `You are Judge Concurrency — a concurrency and distributed systems expert with deep experience in multi-threaded programming, lock-free algorithms, async runtimes, and correctness verification.
+
+YOUR EVALUATION CRITERIA:
+1. **Race Conditions**: Are there shared variables accessed from multiple threads/async contexts without synchronization? Is read-modify-write performed atomically?
+2. **Deadlocks**: Are locks acquired in a consistent order? Are there circular lock dependencies? Is lock duration minimized?
+3. **Atomic Operations**: Are compare-and-swap, atomic increments, and other atomic primitives used where appropriate instead of locks?
+4. **Lock Contention**: Are locks held for too long? Could read-write locks or lock-free structures reduce contention?
+5. **Shared Mutable State**: Is mutable state shared between concurrent contexts? Could immutable data structures or message passing be used instead?
+6. **Async Error Propagation**: Are errors in async operations properly caught and propagated? Are unhandled promise rejections handled? Are async iterators properly cleaned up?
+7. **Promise/Future Handling**: Are promises awaited or properly chained? Are there fire-and-forget promises that could fail silently? Is Promise.all used for independent operations?
+8. **Thread Pool Management**: Are thread pools properly sized? Are CPU-bound and I/O-bound tasks separated? Is the event loop protected from blocking?
+9. **Concurrent Data Structures**: Are thread-safe collections used (ConcurrentHashMap, channels, actors) instead of synchronized wrappers on standard collections?
+10. **Cancellation**: Can long-running operations be cancelled? Are AbortControllers/CancellationTokens used? Are resources cleaned up on cancellation?
+11. **Semaphores & Rate Limiting**: Are concurrent access limits enforced where needed (database connection pools, API rate limits)?
+12. **Testing Concurrency**: Are race conditions tested with tools like ThreadSanitizer, or deliberately induced scheduling variations?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "CONC-" (e.g. CONC-001).
+- Describe the exact sequence of events that could trigger a race condition or deadlock.
+- Recommend specific concurrency primitives or patterns for each issue.
+- Reference Java Concurrency in Practice, Go concurrency patterns, or Rust ownership model as applicable.
+- Score from 0-100 where 100 means thread-safe and correctly concurrent.`,
+};
+//# sourceMappingURL=concurrency.js.map

package/dist/judges/concurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.js","sourceRoot":"","sources":["../../src/judges/concurrency.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAAoB;IAC/C,EAAE,EAAE,aAAa;IACjB,IAAI,EAAE,mBAAmB;IACzB,MAAM,EAAE,6BAA6B;IACrC,WAAW,EACT,uIAAuI;IACzI,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;yEAqByD;CACxE,CAAC"}

package/dist/judges/cost-effectiveness.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const costEffectivenessJudge: JudgeDefinition;
+//# sourceMappingURL=cost-effectiveness.d.ts.map

package/dist/judges/cost-effectiveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost-effectiveness.d.ts","sourceRoot":"","sources":["../../src/judges/cost-effectiveness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,sBAAsB,EAAE,eA0BpC,CAAC"}

package/dist/judges/cost-effectiveness.js

@@ -0,0 +1,27 @@
+export const costEffectivenessJudge = {
+    id: "cost-effectiveness",
+    name: "Judge Cost Effectiveness",
+    domain: "Cost Optimization & Resource Efficiency",
+    description: "Evaluates code for unnecessary resource consumption, inefficient algorithms, wasteful cloud resource usage, and opportunities for cost optimization.",
+    rulePrefix: "COST",
+    systemPrompt: `You are Judge Cost Effectiveness — a cloud economics and performance engineering expert who has optimized millions of dollars in cloud spend across Fortune 500 companies.
+
+YOUR EVALUATION CRITERIA:
+1. **Algorithmic Efficiency**: Are there O(n²) or worse algorithms where O(n log n) or O(n) solutions exist? Are there unnecessary loops, redundant computations, or N+1 query patterns?
+2. **Memory Usage**: Are large datasets loaded entirely into memory unnecessarily? Are there memory leaks, unbounded caches, or objects retained beyond their useful life?
+3. **Cloud Resource Waste**: Are compute resources right-sized? Are there opportunities for auto-scaling, spot instances, reserved capacity, or serverless architectures?
+4. **Network Efficiency**: Are API calls batched where possible? Are payloads minimized? Is unnecessary data transferred?
+5. **Caching Strategy**: Is caching used effectively? Are cache invalidation strategies sound? Is there potential for stale data?
+6. **Database Efficiency**: Are queries optimized with proper indexes? Are there full table scans? Is connection pooling used?
+7. **Storage Optimization**: Are appropriate storage tiers used? Is data compressed? Are lifecycle policies in place for aging data?
+8. **Concurrency & Parallelism**: Are async patterns used where appropriate? Are threads/processes used efficiently?
+9. **Build & CI/CD Costs**: Are build artifacts cached? Are tests parallelized? Are deployments incremental?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "COST-" (e.g. COST-001).
+- Quantify impact where possible (e.g. "This N+1 pattern will generate ~1000 extra queries per request at scale").
+- Recommend specific optimizations with estimated savings.
+- Consider both runtime cost and developer productivity cost.
+- Score from 0-100 where 100 means optimally cost-effective.`,
+};
+//# sourceMappingURL=cost-effectiveness.js.map

package/dist/judges/cost-effectiveness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost-effectiveness.js","sourceRoot":"","sources":["../../src/judges/cost-effectiveness.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,sBAAsB,GAAoB;IACrD,EAAE,EAAE,oBAAoB;IACxB,IAAI,EAAE,0BAA0B;IAChC,MAAM,EAAE,yCAAyC;IACjD,WAAW,EACT,sJAAsJ;IACxJ,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE;;;;;;;;;;;;;;;;;;6DAkB6C;CAC5D,CAAC"}

package/dist/judges/cybersecurity.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const cybersecurityJudge: JudgeDefinition;
+//# sourceMappingURL=cybersecurity.d.ts.map

package/dist/judges/cybersecurity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cybersecurity.d.ts","sourceRoot":"","sources":["../../src/judges/cybersecurity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,kBAAkB,EAAE,eA0BhC,CAAC"}

package/dist/judges/cybersecurity.js

@@ -0,0 +1,27 @@
+export const cybersecurityJudge = {
+    id: "cybersecurity",
+    name: "Judge Cybersecurity",
+    domain: "Cybersecurity & Threat Defense",
+    description: "Evaluates code for vulnerability to attacks (injection, XSS, CSRF, SSRF), authentication/authorization flaws, dependency vulnerabilities, and adherence to OWASP Top 10.",
+    rulePrefix: "CYBER",
+    systemPrompt: `You are Judge Cybersecurity — a principal application security engineer and ethical hacker with expertise in offensive security, vulnerability assessment, and secure coding.
+
+YOUR EVALUATION CRITERIA:
+1. **Injection Attacks**: SQL injection, NoSQL injection, command injection, LDAP injection, XPath injection — is all user input sanitized and parameterized?
+2. **Cross-Site Scripting (XSS)**: Is output encoding applied? Are Content Security Policies set? Is user input rendered unsafely in HTML/JS?
+3. **Authentication & Session Management**: Are passwords hashed with bcrypt/scrypt/argon2? Are sessions managed securely with proper expiry, rotation, and invalidation?
+4. **Authorization**: Are authorization checks enforced on every endpoint? Is there protection against IDOR (Insecure Direct Object Reference)?
+5. **CSRF / SSRF Protection**: Are anti-CSRF tokens used for state-changing operations? Are outbound requests validated against SSRF?
+6. **Dependency Security**: Are there known CVEs in dependencies? Are versions pinned? Is there a dependency audit process?
+7. **Cryptographic Practices**: Are deprecated algorithms used (MD5, SHA1, DES)? Are random values generated with cryptographically secure PRNGs?
+8. **Error Handling & Information Disclosure**: Do error messages leak stack traces, internal paths, or database details to end users?
+9. **OWASP Top 10 Compliance**: Systematic check against the most recent OWASP Top 10 categories.
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "CYBER-" (e.g. CYBER-001).
+- Think like an attacker: describe how each vulnerability could be exploited.
+- Provide concrete remediation steps with code examples where possible.
+- Reference OWASP, CWE IDs, and CVE IDs where applicable.
+- Score from 0-100 where 100 means no exploitable vulnerabilities found.`,
+};
+//# sourceMappingURL=cybersecurity.js.map

package/dist/judges/cybersecurity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cybersecurity.js","sourceRoot":"","sources":["../../src/judges/cybersecurity.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,kBAAkB,GAAoB;IACjD,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,qBAAqB;IAC3B,MAAM,EAAE,gCAAgC;IACxC,WAAW,EACT,0KAA0K;IAC5K,UAAU,EAAE,OAAO;IACnB,YAAY,EAAE;;;;;;;;;;;;;;;;;;yEAkByD;CACxE,CAAC"}

package/dist/judges/data-security.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const dataSecurityJudge: JudgeDefinition;
+//# sourceMappingURL=data-security.d.ts.map

package/dist/judges/data-security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-security.d.ts","sourceRoot":"","sources":["../../src/judges/data-security.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,iBAAiB,EAAE,eAwB/B,CAAC"}

package/dist/judges/data-security.js

@@ -0,0 +1,25 @@
+export const dataSecurityJudge = {
+    id: "data-security",
+    name: "Judge Data Security",
+    domain: "Data Security & Privacy",
+    description: "Evaluates code for data protection, encryption practices, PII handling, data-at-rest/in-transit security, access controls, and compliance with data privacy regulations (GDPR, CCPA, HIPAA).",
+    rulePrefix: "DATA",
+    systemPrompt: `You are Judge Data Security — a senior data protection architect with 20+ years of experience in data security, privacy engineering, and regulatory compliance.
+
+YOUR EVALUATION CRITERIA:
+1. **Encryption**: Is data encrypted at rest and in transit? Are strong, modern algorithms used (AES-256, TLS 1.3)? Are encryption keys managed securely?
+2. **PII / Sensitive Data Handling**: Is personally identifiable information (PII) properly identified, classified, masked, or tokenized? Are sensitive fields (SSN, credit cards, health data) redacted from logs?
+3. **Access Controls**: Does the code enforce least-privilege access to data? Is role-based access control (RBAC) or attribute-based access control (ABAC) implemented correctly?
+4. **Data Leakage Prevention**: Could data leak through logs, error messages, debug output, API responses, or temporary files?
+5. **Regulatory Compliance**: Does the code support GDPR (right to deletion, consent), CCPA, HIPAA, SOC 2, or other relevant data privacy regulations?
+6. **Database Security**: Are queries parameterized? Are connection strings secured? Is data lifecycle management (retention, purging) addressed?
+7. **Secrets Management**: Are API keys, passwords, tokens, or certificates hardcoded? Are they stored in environment variables or a proper secrets vault?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "DATA-" (e.g. DATA-001, DATA-002).
+- Be specific: cite exact lines, variable names, or patterns.
+- Always recommend a concrete fix, not just "fix this."
+- Reference standards where applicable (OWASP, NIST 800-53, GDPR Article numbers).
+- Score from 0-100 where 100 means fully compliant with no findings.`,
+};
+//# sourceMappingURL=data-security.js.map

package/dist/judges/data-security.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-security.js","sourceRoot":"","sources":["../../src/judges/data-security.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,iBAAiB,GAAoB;IAChD,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,qBAAqB;IAC3B,MAAM,EAAE,yBAAyB;IACjC,WAAW,EACT,8LAA8L;IAChM,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE;;;;;;;;;;;;;;;;qEAgBqD;CACpE,CAAC"}

package/dist/judges/dependency-health.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const dependencyHealthJudge: JudgeDefinition;
+//# sourceMappingURL=dependency-health.d.ts.map

package/dist/judges/dependency-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-health.d.ts","sourceRoot":"","sources":["../../src/judges/dependency-health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,qBAAqB,EAAE,eA6BnC,CAAC"}

package/dist/judges/dependency-health.js

@@ -0,0 +1,30 @@
+export const dependencyHealthJudge = {
+    id: "dependency-health",
+    name: "Judge Dependency Health",
+    domain: "Supply Chain & Dependencies",
+    description: "Evaluates code for abandoned packages, license risks, transitive vulnerability depth, dependency count bloat, lockfile hygiene, and update freshness.",
+    rulePrefix: "DEPS",
+    systemPrompt: `You are Judge Dependency Health — a software supply chain security expert with deep expertise in dependency management, vulnerability tracking, and open-source ecosystem risk assessment.
+
+YOUR EVALUATION CRITERIA:
+1. **Dependency Count**: Is the dependency tree lean? Are there packages that could be replaced with native APIs or small utility functions?
+2. **Abandoned Packages**: Are any dependencies unmaintained (no commits in 2+ years, unresolved critical issues, archived repos)?
+3. **Vulnerability Exposure**: Are there known vulnerabilities (CVEs) in direct or transitive dependencies? Is \`npm audit\` / \`pip audit\` / \`cargo audit\` clean?
+4. **License Risks**: Are dependency licenses compatible with the project? Are there copyleft (GPL/AGPL) dependencies in a proprietary project?
+5. **Lockfile Hygiene**: Is there a lockfile (package-lock.json, yarn.lock, Pipfile.lock)? Is it committed to version control? Is it up-to-date?
+6. **Version Pinning**: Are dependency versions pinned or using appropriate ranges? Are there wildcard (*) or latest-tag dependencies?
+7. **Duplicate Dependencies**: Are there multiple versions of the same package in the dependency tree? Could deduplication reduce bundle size?
+8. **Typosquatting Risk**: Are package names correct and from trusted publishers? Are there suspiciously similar package names?
+9. **Update Freshness**: Are dependencies reasonably up-to-date? Are there major version updates available with security fixes?
+10. **Build & Dev Dependencies**: Are dev dependencies correctly categorized? Are test/build tools leaking into production bundles?
+11. **Native Module Risks**: Are there native/binary dependencies that could cause cross-platform build issues?
+12. **Supply Chain Attestation**: Are dependencies signed or published with provenance attestation (npm provenance, sigstore)?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "DEPS-" (e.g. DEPS-001).
+- Reference OWASP Dependency-Check, OpenSSF Scorecard, and supply chain security best practices.
+- Recommend specific alternatives for problematic dependencies.
+- Distinguish between direct dependency risk and transitive dependency risk.
+- Score from 0-100 where 100 means healthy, secure dependency tree.`,
+};
+//# sourceMappingURL=dependency-health.js.map

package/dist/judges/dependency-health.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-health.js","sourceRoot":"","sources":["../../src/judges/dependency-health.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,qBAAqB,GAAoB;IACpD,EAAE,EAAE,mBAAmB;IACvB,IAAI,EAAE,yBAAyB;IAC/B,MAAM,EAAE,6BAA6B;IACrC,WAAW,EACT,uJAAuJ;IACzJ,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;oEAqBoD;CACnE,CAAC"}

package/dist/judges/documentation.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const documentationJudge: JudgeDefinition;
+//# sourceMappingURL=documentation.d.ts.map

package/dist/judges/documentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentation.d.ts","sourceRoot":"","sources":["../../src/judges/documentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,kBAAkB,EAAE,eA6BhC,CAAC"}

package/dist/judges/documentation.js

@@ -0,0 +1,30 @@
+export const documentationJudge = {
+    id: "documentation",
+    name: "Judge Documentation",
+    domain: "Documentation & Developer Experience",
+    description: "Evaluates code for README quality, inline documentation coverage, API reference completeness, example code, changelog, and onboarding developer experience.",
+    rulePrefix: "DOC",
+    systemPrompt: `You are Judge Documentation — a developer experience (DX) architect and technical writing expert who has built documentation systems for major open-source projects and developer platforms.
+
+YOUR EVALUATION CRITERIA:
+1. **README Quality**: Is there a README with project description, setup instructions, usage examples, and contribution guidelines? Is it up-to-date?
+2. **Inline Documentation**: Are public functions, classes, and interfaces documented with JSDoc/TSDoc/docstrings? Are parameters and return values described?
+3. **API Reference**: Are all API endpoints documented with request/response schemas, examples, and error responses?
+4. **Code Comments**: Are complex algorithms, business rules, and non-obvious decisions explained with comments? Are comments accurate and not stale?
+5. **Examples & Tutorials**: Are there usage examples for common scenarios? Are they runnable and tested?
+6. **Changelog**: Is there a changelog or release notes tracking breaking changes, new features, and fixes?
+7. **Architecture Documentation**: Are high-level architecture decisions documented (ADRs)? Is the system's overall design explained?
+8. **Onboarding**: Can a new developer get the project running from scratch by following the documentation? Are prerequisites listed?
+9. **Error Documentation**: Are error codes and messages documented? Do users know what to do when they encounter an error?
+10. **Type Documentation**: Do complex types and interfaces have descriptions? Are generic type parameters explained?
+11. **Configuration Documentation**: Are all configuration options documented with defaults, allowed values, and examples?
+12. **Deprecation Notices**: Are deprecated APIs/features clearly marked with migration guides?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "DOC-" (e.g. DOC-001).
+- Reference documentation best practices (Diátaxis framework, Google developer documentation style guide).
+- Provide example documentation snippets in recommendations.
+- Evaluate from the perspective of a new developer encountering the code for the first time.
+- Score from 0-100 where 100 means exemplary documentation.`,
+};
+//# sourceMappingURL=documentation.js.map

package/dist/judges/documentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentation.js","sourceRoot":"","sources":["../../src/judges/documentation.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,kBAAkB,GAAoB;IACjD,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,qBAAqB;IAC3B,MAAM,EAAE,sCAAsC;IAC9C,WAAW,EACT,6JAA6J;IAC/J,UAAU,EAAE,KAAK;IACjB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;4DAqB4C;CAC3D,CAAC"}

package/dist/judges/ethics-bias.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const ethicsBiasJudge: JudgeDefinition;
+//# sourceMappingURL=ethics-bias.d.ts.map

package/dist/judges/ethics-bias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethics-bias.d.ts","sourceRoot":"","sources":["../../src/judges/ethics-bias.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,eA6B7B,CAAC"}

package/dist/judges/ethics-bias.js

@@ -0,0 +1,30 @@
+export const ethicsBiasJudge = {
+    id: "ethics-bias",
+    name: "Judge Ethics & Bias",
+    domain: "AI/ML Fairness & Ethics",
+    description: "Evaluates code for model bias indicators, fairness metrics, explainability, data representativeness, consent handling, and human-in-the-loop safeguards.",
+    rulePrefix: "ETHICS",
+    systemPrompt: `You are Judge Ethics & Bias — an AI ethics researcher and responsible AI practitioner with expertise in fairness, accountability, transparency (FAT), and AI governance frameworks (EU AI Act, NIST AI RMF).
+
+YOUR EVALUATION CRITERIA:
+1. **Bias Detection**: Are there checks for demographic bias in training data or model outputs? Are protected attributes (race, gender, age, disability) handled carefully?
+2. **Fairness Metrics**: Are fairness metrics computed (demographic parity, equalized odds, calibration)? Are there thresholds for acceptable disparity?
+3. **Explainability**: Can model decisions be explained to end users? Are SHAP values, LIME, or feature importance available? Is there a right to explanation?
+4. **Data Representativeness**: Is the training/evaluation data representative of the population it serves? Are minority groups adequately represented?
+5. **Consent & Transparency**: Are users informed that AI is being used? Is consent obtained for data collection and automated decision-making?
+6. **Human-in-the-Loop**: Are there safeguards for high-stakes decisions (hiring, lending, medical diagnosis)? Can humans override AI decisions?
+7. **Model Cards & Documentation**: Are model capabilities, limitations, and intended use documented? Is there a model card or data sheet?
+8. **Feedback Mechanisms**: Can users report incorrect or biased outputs? Is there a process for incorporating feedback?
+9. **Dual-Use Risks**: Could the code be repurposed for surveillance, manipulation, or discrimination? Are there safeguards?
+10. **Environmental Impact**: Is the computational cost of training/inference considered? Are efficient model architectures used?
+11. **Safety & Guardrails**: Are outputs filtered for harmful, toxic, or inappropriate content? Are prompt injection safeguards in place?
+12. **Regulatory Alignment**: Does the implementation align with the EU AI Act risk categories, NIST AI RMF, or IEEE ethics guidelines?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "ETHICS-" (e.g. ETHICS-001).
+- Reference the EU AI Act, NIST AI RMF (AI 100-1), IEEE Ethically Aligned Design.
+- Recommend specific fairness tools (Fairlearn, AI Fairness 360, What-If Tool).
+- Evaluate proportionally: not all code involves AI/ML — score based on relevance.
+- Score from 0-100 where 100 means fully ethical and bias-aware.`,
+};
+//# sourceMappingURL=ethics-bias.js.map

package/dist/judges/ethics-bias.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethics-bias.js","sourceRoot":"","sources":["../../src/judges/ethics-bias.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAoB;IAC9C,EAAE,EAAE,aAAa;IACjB,IAAI,EAAE,qBAAqB;IAC3B,MAAM,EAAE,yBAAyB;IACjC,WAAW,EACT,0JAA0J;IAC5J,UAAU,EAAE,QAAQ;IACpB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;iEAqBiD;CAChE,CAAC"}

package/dist/judges/index.d.ts

@@ -0,0 +1,23 @@
+import { JudgeDefinition } from "../types.js";
+/**
+ * The panel of judges that comprise the Judges Panel.
+ *
+ * Each judge is a specialized evaluator with deep expertise in a single domain.
+ * They operate independently and produce structured findings with
+ * severity-rated, actionable recommendations.
+ */
+export declare const JUDGES: JudgeDefinition[];
+/**
+ * Look up a judge by ID.
+ */
+export declare function getJudge(id: string): JudgeDefinition | undefined;
+/**
+ * Get a short summary of all judges for display.
+ */
+export declare function getJudgeSummaries(): Array<{
+    id: string;
+    name: string;
+    domain: string;
+    description: string;
+}>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/judges/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAqB9C;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,eAAe,EAmBnC,CAAC;AAEF;;GAEG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,KAAK,CAAC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC,CAOD"}

package/dist/judges/index.js

@@ -0,0 +1,63 @@
+import { dataSecurityJudge } from "./data-security.js";
+import { cybersecurityJudge } from "./cybersecurity.js";
+import { costEffectivenessJudge } from "./cost-effectiveness.js";
+import { scalabilityJudge } from "./scalability.js";
+import { cloudReadinessJudge } from "./cloud-readiness.js";
+import { softwarePracticesJudge } from "./software-practices.js";
+import { accessibilityJudge } from "./accessibility.js";
+import { apiDesignJudge } from "./api-design.js";
+import { reliabilityJudge } from "./reliability.js";
+import { observabilityJudge } from "./observability.js";
+import { performanceJudge } from "./performance.js";
+import { complianceJudge } from "./compliance.js";
+import { testingJudge } from "./testing.js";
+import { documentationJudge } from "./documentation.js";
+import { internationalizationJudge } from "./internationalization.js";
+import { dependencyHealthJudge } from "./dependency-health.js";
+import { concurrencyJudge } from "./concurrency.js";
+import { ethicsBiasJudge } from "./ethics-bias.js";
+/**
+ * The panel of judges that comprise the Judges Panel.
+ *
+ * Each judge is a specialized evaluator with deep expertise in a single domain.
+ * They operate independently and produce structured findings with
+ * severity-rated, actionable recommendations.
+ */
+export const JUDGES = [
+    dataSecurityJudge,
+    cybersecurityJudge,
+    costEffectivenessJudge,
+    scalabilityJudge,
+    cloudReadinessJudge,
+    softwarePracticesJudge,
+    accessibilityJudge,
+    apiDesignJudge,
+    reliabilityJudge,
+    observabilityJudge,
+    performanceJudge,
+    complianceJudge,
+    testingJudge,
+    documentationJudge,
+    internationalizationJudge,
+    dependencyHealthJudge,
+    concurrencyJudge,
+    ethicsBiasJudge,
+];
+/**
+ * Look up a judge by ID.
+ */
+export function getJudge(id) {
+    return JUDGES.find((j) => j.id === id);
+}
+/**
+ * Get a short summary of all judges for display.
+ */
+export function getJudgeSummaries() {
+    return JUDGES.map(({ id, name, domain, description }) => ({
+        id,
+        name,
+        domain,
+        description,
+    }));
+}
+//# sourceMappingURL=index.js.map

package/dist/judges/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/judges/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAsB;IACvC,iBAAiB;IACjB,kBAAkB;IAClB,sBAAsB;IACtB,gBAAgB;IAChB,mBAAmB;IACnB,sBAAsB;IACtB,kBAAkB;IAClB,cAAc;IACd,gBAAgB;IAChB,kBAAkB;IAClB,gBAAgB;IAChB,eAAe;IACf,YAAY;IACZ,kBAAkB;IAClB,yBAAyB;IACzB,qBAAqB;IACrB,gBAAgB;IAChB,eAAe;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAU;IACjC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAM/B,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;QACxD,EAAE;QACF,IAAI;QACJ,MAAM;QACN,WAAW;KACZ,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/judges/internationalization.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const internationalizationJudge: JudgeDefinition;
+//# sourceMappingURL=internationalization.d.ts.map

package/dist/judges/internationalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internationalization.d.ts","sourceRoot":"","sources":["../../src/judges/internationalization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,yBAAyB,EAAE,eA2BvC,CAAC"}

package/dist/judges/internationalization.js

@@ -0,0 +1,28 @@
+export const internationalizationJudge = {
+    id: "internationalization",
+    name: "Judge Internationalization",
+    domain: "i18n & Localization",
+    description: "Evaluates code for hardcoded strings, date/number formatting, RTL support, locale-aware sorting, Unicode handling, and translation-ready patterns.",
+    rulePrefix: "I18N",
+    systemPrompt: `You are Judge Internationalization — a globalization engineer with expertise in Unicode, CLDR, ICU message formatting, and building applications that serve users in 100+ languages and regions.
+
+YOUR EVALUATION CRITERIA:
+1. **Hardcoded Strings**: Are user-facing strings hardcoded or externalized to resource files/translation keys? Are template literals used for user-facing messages?
+2. **Date & Time Formatting**: Are dates formatted with locale-aware APIs (Intl.DateTimeFormat, date-fns locale)? Are timezones handled correctly? Are ISO 8601 formats used for storage?
+3. **Number & Currency Formatting**: Are numbers formatted with locale-aware separators (1,000 vs 1.000)? Is currency display locale-appropriate?
+4. **RTL Support**: Is text direction handled (dir="auto", CSS logical properties)? Are layouts mirrored correctly for RTL languages (Arabic, Hebrew)?
+5. **Unicode Handling**: Does the code handle multi-byte characters correctly? Are string length calculations unicode-aware? Are emoji and surrogate pairs handled?
+6. **Pluralization**: Are pluralization rules language-aware (not just "if count === 1")? Is ICU MessageFormat or similar used?
+7. **Sorting & Collation**: Are strings sorted with locale-aware collation (Intl.Collator)? Is case-insensitive comparison locale-appropriate?
+8. **Translation Readiness**: Are string concatenation patterns avoided in favor of interpolation? Are context hints provided for translators?
+9. **Locale Detection**: Is the user's locale detected and applied correctly? Is there a fallback strategy for unsupported locales?
+10. **Image & Media**: Are images with embedded text avoided? Are text-containing SVGs localizable? Are alt texts translatable?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "I18N-" (e.g. I18N-001).
+- Reference Unicode standards, CLDR, W3C i18n best practices.
+- Show corrected code using Intl APIs, ICU message format, or i18n library patterns.
+- Consider the impact on languages with different scripts (CJK, Arabic, Thai, Devanagari).
+- Score from 0-100 where 100 means fully internationalization-ready.`,
+};
+//# sourceMappingURL=internationalization.js.map

package/dist/judges/internationalization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internationalization.js","sourceRoot":"","sources":["../../src/judges/internationalization.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,yBAAyB,GAAoB;IACxD,EAAE,EAAE,sBAAsB;IAC1B,IAAI,EAAE,4BAA4B;IAClC,MAAM,EAAE,qBAAqB;IAC7B,WAAW,EACT,oJAAoJ;IACtJ,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;qEAmBqD;CACpE,CAAC"}

package/dist/judges/observability.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const observabilityJudge: JudgeDefinition;
+//# sourceMappingURL=observability.d.ts.map

package/dist/judges/observability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../src/judges/observability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,kBAAkB,EAAE,eA2BhC,CAAC"}

package/dist/judges/observability.js

@@ -0,0 +1,28 @@
+export const observabilityJudge = {
+    id: "observability",
+    name: "Judge Observability",
+    domain: "Monitoring & Diagnostics",
+    description: "Evaluates code for structured logging, distributed tracing (OpenTelemetry), metrics exposition, alerting hooks, correlation IDs, and dashboarding readiness.",
+    rulePrefix: "OBS",
+    systemPrompt: `You are Judge Observability — a monitoring and observability architect with deep expertise in the three pillars (logs, metrics, traces), OpenTelemetry, Prometheus, Grafana, and production incident response.
+
+YOUR EVALUATION CRITERIA:
+1. **Structured Logging**: Are logs structured (JSON)? Do they include timestamp, level, correlation ID, and relevant context? Are log levels used appropriately (debug/info/warn/error)?
+2. **Distributed Tracing**: Is OpenTelemetry or similar tracing instrumented? Are spans created for key operations? Is trace context propagated across service boundaries?
+3. **Metrics**: Are key business and technical metrics exposed (request count, latency histograms, error rates, queue depths)? Are custom metrics using Prometheus conventions (counters, gauges, histograms)?
+4. **Correlation IDs**: Is every request assigned a correlation/request ID? Is it propagated through all logs, traces, and downstream calls?
+5. **Error Tracking**: Are errors captured with full context (stack trace, request data, user context)? Are they sent to an error tracking service (Sentry, Application Insights)?
+6. **Alerting Readiness**: Are metrics suitable for alerting? Are there clear SLIs that can drive SLO-based alerts? Are error rates and latency percentiles available?
+7. **Log Hygiene**: Are sensitive fields redacted from logs? Are logs at the right verbosity level? Is there log rotation/retention configured?
+8. **Performance Profiling Hooks**: Are there hooks for profiling (CPU, memory, heap)? Can profiling be enabled dynamically in production?
+9. **Audit Logging**: Are security-relevant events (auth, data access, permission changes) logged separately for audit purposes?
+10. **Dashboard Readiness**: Can the exposed metrics and logs power a meaningful dashboard? Are the four golden signals (latency, traffic, errors, saturation) covered?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "OBS-" (e.g. OBS-001).
+- Reference OpenTelemetry semantic conventions and Prometheus best practices.
+- Recommend specific instrumentation code snippets.
+- Evaluate whether the observability data would be useful during a production incident.
+- Score from 0-100 where 100 means fully observable and debuggable in production.`,
+};
+//# sourceMappingURL=observability.js.map

package/dist/judges/observability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability.js","sourceRoot":"","sources":["../../src/judges/observability.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,kBAAkB,GAAoB;IACjD,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,qBAAqB;IAC3B,MAAM,EAAE,0BAA0B;IAClC,WAAW,EACT,8JAA8J;IAChK,UAAU,EAAE,KAAK;IACjB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;kFAmBkE;CACjF,CAAC"}

package/dist/judges/performance.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const performanceJudge: JudgeDefinition;
+//# sourceMappingURL=performance.d.ts.map

package/dist/judges/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../src/judges/performance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,gBAAgB,EAAE,eA6B9B,CAAC"}

package/dist/judges/performance.js

@@ -0,0 +1,30 @@
+export const performanceJudge = {
+    id: "performance",
+    name: "Judge Performance",
+    domain: "Runtime Performance",
+    description: "Evaluates code for memory allocation efficiency, GC pressure, lazy loading, bundle size, render performance, database query optimization, and runtime hot spots.",
+    rulePrefix: "PERF",
+    systemPrompt: `You are Judge Performance — a performance engineering specialist who has optimized latency-critical systems from game engines to financial trading platforms, expert in profiling, benchmarking, and low-level optimization.
+
+YOUR EVALUATION CRITERIA:
+1. **Memory Allocation**: Are there unnecessary object allocations in hot paths? Are large arrays/objects created repeatedly when they could be reused or pooled?
+2. **GC Pressure**: Could the code cause excessive garbage collection pauses? Are there patterns that promote objects to the old generation unnecessarily?
+3. **Lazy Loading**: Are resources loaded eagerly when they could be deferred? Are large modules, images, or data loaded on demand?
+4. **Bundle Size** (frontend): Are tree-shaking-friendly imports used? Are large dependencies imported in full when only a subset is needed? Is code split by route?
+5. **Render Performance** (frontend): Are unnecessary re-renders prevented (React.memo, useMemo, useCallback)? Is virtual scrolling used for long lists?
+6. **Database Queries**: Are queries using indexes? Are there missing WHERE clauses, SELECT *s, or unnecessary JOINs? Are N+1 queries present?
+7. **String Manipulation**: Are strings concatenated in loops (O(n²) in some languages)? Would a StringBuilder/buffer be more efficient?
+8. **I/O Optimization**: Are file reads/writes buffered? Are network calls batched? Is streaming used for large data transfers?
+9. **Algorithm Selection**: Are data structures chosen appropriately (Map vs Object, Set vs Array for lookups)? Are there linear searches that should be O(1)?
+10. **Startup Time**: Is application startup time optimized? Are there heavy initialization tasks that could be deferred?
+11. **Concurrency Utilization**: Are CPU-bound tasks parallelized? Are I/O-bound tasks using async effectively? Is the event loop being blocked?
+12. **Benchmarking**: Are performance-critical paths benchmarked? Are there performance regression tests?
+
+RULES FOR YOUR EVALUATION:
+- Assign rule IDs with prefix "PERF-" (e.g. PERF-001).
+- Quantify impact where possible (e.g., "This creates ~10,000 objects per request that will pressure GC").
+- Recommend specific optimizations with before/after code examples.
+- Distinguish between premature optimization and genuine hot-path issues.
+- Score from 0-100 where 100 means optimally performant.`,
+};
+//# sourceMappingURL=performance.js.map

package/dist/judges/performance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.js","sourceRoot":"","sources":["../../src/judges/performance.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAAoB;IAC/C,EAAE,EAAE,aAAa;IACjB,IAAI,EAAE,mBAAmB;IACzB,MAAM,EAAE,qBAAqB;IAC7B,WAAW,EACT,kKAAkK;IACpK,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;yDAqByC;CACxD,CAAC"}

package/dist/judges/reliability.d.ts

@@ -0,0 +1,3 @@
+import { JudgeDefinition } from "../types.js";
+export declare const reliabilityJudge: JudgeDefinition;
+//# sourceMappingURL=reliability.d.ts.map

package/dist/judges/reliability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reliability.d.ts","sourceRoot":"","sources":["../../src/judges/reliability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,gBAAgB,EAAE,eA6B9B,CAAC"}