@sourcey/catalog-verifier 1.1.4 → 1.1.5

package/dist/modules/catalog-admission/src/machine-admission.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { DecisionBasis } from "../../../contracts/authority/src/index.js";
+export declare const entityPathSchema: z.ZodString;
 export declare const startupCreditsMachineAdmissionPolicyCoreSchema: z.ZodObject<{
     policy_contract: z.ZodLiteral<"sourcey.startup-credits-machine-admission-policy/v1alpha1">;
     policy_id: z.ZodString;
@@ -262,6 +262,10 @@ export declare const startupCreditsMachineAdmissionInputCoreSchema: z.ZodObject<
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -291,6 +295,10 @@ export declare const startupCreditsMachineAdmissionInputCoreSchema: z.ZodObject<
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -353,6 +361,10 @@ export declare const startupCreditsMachineAdmissionInputCoreSchema: z.ZodObject<
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -373,6 +385,10 @@ export declare const startupCreditsMachineAdmissionInputCoreSchema: z.ZodObject<
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -822,6 +838,10 @@ export declare const startupCreditsMachineAdmissionInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -851,6 +871,10 @@ export declare const startupCreditsMachineAdmissionInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -913,6 +937,10 @@ export declare const startupCreditsMachineAdmissionInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -933,6 +961,10 @@ export declare const startupCreditsMachineAdmissionInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -1376,6 +1408,10 @@ export declare const startupCreditsAdmissionCandidateInputCoreSchema: z.ZodObjec
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -1405,6 +1441,10 @@ export declare const startupCreditsAdmissionCandidateInputCoreSchema: z.ZodObjec
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -1467,6 +1507,10 @@ export declare const startupCreditsAdmissionCandidateInputCoreSchema: z.ZodObjec
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -1487,6 +1531,10 @@ export declare const startupCreditsAdmissionCandidateInputCoreSchema: z.ZodObjec
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -1930,6 +1978,10 @@ export declare const startupCreditsAdmissionCandidateInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -1959,6 +2011,10 @@ export declare const startupCreditsAdmissionCandidateInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -2021,6 +2077,10 @@ export declare const startupCreditsAdmissionCandidateInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -2041,6 +2101,10 @@ export declare const startupCreditsAdmissionCandidateInputSchema: z.ZodObject<{
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"at-least">;
                         value: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"range">;
+                        minimum: z.ZodString;
+                        maximum: z.ZodString;
                     }, z.core.$strict>], "kind">>;
                 }, z.core.$strict>, z.ZodObject<{
                     benefit_id: z.ZodString;
@@ -2499,22 +2563,4 @@ export declare function createStartupCreditsMachineAdmissionInput(input: z.input
  * they never change this candidate's evidence, conflicts, policy or outcome.
  */
 export declare function createStartupCreditsAdmissionCandidateInput(input: z.input<typeof startupCreditsAdmissionCandidateInputCoreSchema>): StartupCreditsAdmissionCandidateInput;
-export declare function createStartupCreditsMachineAdmissionPolicy(input: z.input<typeof startupCreditsMachineAdmissionPolicyCoreSchema>): StartupCreditsMachineAdmissionPolicy;
-/** One total pure policy over exact, already verified domain results. */
-export declare function evaluateStartupCreditsMachineAdmission(input: unknown): {
-    readonly input: StartupCreditsMachineAdmissionInput;
-    readonly result: StartupCreditsMachineAdmissionResult;
-    readonly receipt: StartupCreditsMachineAdmissionReceipt;
-    readonly decisionBasis: DecisionBasis;
-};
-/**
- * The shared deterministic admission verdict used by transport-specific
- * applications. This emits no publication, payment, Git or reviewer authority.
- */
-export declare function evaluateStartupCreditsAdmissionCandidate(input: unknown): {
-    readonly input: StartupCreditsAdmissionCandidateInput;
-    readonly result: StartupCreditsAdmissionCandidateResult;
-    readonly receipt: StartupCreditsAdmissionCandidateReceipt;
-    readonly decisionBasis: DecisionBasis;
-};
 //# sourceMappingURL=machine-admission.d.ts.map

package/dist/modules/catalog-admission/src/machine-admission.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"machine-admission.d.ts","sourceRoot":"","sources":["../../../../modules/catalog-admission/src/machine-admission.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAmC/E,eAAO,MAAM,8CAA8C;;;;;;;;;;;;kBAgBhD,CAAC;AAEZ,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;kBAC0C,CAAC;AA8HlG,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoF/C,CAAC;AAEZ,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACyC,CAAC;AAmBhG,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK/C,CAAC;AAEd,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG3C,CAAC;AAEd,eAAO,MAAM,2CAA2C;;;;;;EAMtD,CAAC;AAEH,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;EAwBrD,CAAC;AAEH,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUhD,CAAC;AAEZ,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC0C,CAAC;AAElG,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUlD,CAAC;AAEZ,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC0C,CAAC;AAEpG,eAAO,MAAM,iDAAiD;;;;;;;;kBAUnD,CAAC;AAEZ,eAAO,MAAM,6CAA6C;;;;;;;;;kBAG7C,CAAC;AAEd,eAAO,MAAM,+CAA+C;;;;;;;;kBAUjD,CAAC;AAEZ,eAAO,MAAM,2CAA2C;;;;;;;;;kBAC2C,CAAC;AAEpG,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AACF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAC;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AACF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,4CAA4C,CACpD,CAAC;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,6CAA6C,CACrD,CAAC;AACF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAC;AAEF,wBAAgB,yCAAyC,CACvD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,6CAA6C,CAAC,GACnE,mCAAmC,CAGrC;AAED;;;;GAIG;AACH,wBAAgB,2CAA2C,CACzD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,+CAA+C,CAAC,GACrE,qCAAqC,CAMvC;AAED,wBAAgB,0CAA0C,CACxD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,8CAA8C,CAAC,GACpE,oCAAoC,CAMtC;AAED,yEAAyE;AACzE,wBAAgB,sCAAsC,CAAC,KAAK,EAAE,OAAO,GAAG;IACtE,QAAQ,CAAC,KAAK,EAAE,mCAAmC,CAAC;IACpD,QAAQ,CAAC,MAAM,EAAE,oCAAoC,CAAC;IACtD,QAAQ,CAAC,OAAO,EAAE,qCAAqC,CAAC;IACxD,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC,CAmDA;AAED;;;GAGG;AACH,wBAAgB,wCAAwC,CAAC,KAAK,EAAE,OAAO,GAAG;IACxE,QAAQ,CAAC,KAAK,EAAE,qCAAqC,CAAC;IACtD,QAAQ,CAAC,MAAM,EAAE,sCAAsC,CAAC;IACxD,QAAQ,CAAC,OAAO,EAAE,uCAAuC,CAAC;IAC1D,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC,CAqDA"}
+{"version":3,"file":"machine-admission.d.ts","sourceRoot":"","sources":["../../../../modules/catalog-admission/src/machine-admission.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,gBAAgB,aAEuC,CAAC;AAErE,eAAO,MAAM,8CAA8C;;;;;;;;;;;;kBAgBhD,CAAC;AAEZ,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;kBAC0C,CAAC;AA8HlG,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoF/C,CAAC;AAEZ,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACyC,CAAC;AAmBhG,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK/C,CAAC;AAEd,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG3C,CAAC;AAEd,eAAO,MAAM,2CAA2C;;;;;;EAMtD,CAAC;AAEH,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;EAwBrD,CAAC;AAEH,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUhD,CAAC;AAEZ,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC0C,CAAC;AAElG,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUlD,CAAC;AAEZ,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC0C,CAAC;AAEpG,eAAO,MAAM,iDAAiD;;;;;;;;kBAUnD,CAAC;AAEZ,eAAO,MAAM,6CAA6C;;;;;;;;;kBAG7C,CAAC;AAEd,eAAO,MAAM,+CAA+C;;;;;;;;kBAUjD,CAAC;AAEZ,eAAO,MAAM,2CAA2C;;;;;;;;;kBAC2C,CAAC;AAEpG,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAC;AACF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAC;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,0CAA0C,CAClD,CAAC;AACF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,4CAA4C,CACpD,CAAC;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,6CAA6C,CACrD,CAAC;AACF,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAC;AAEF,wBAAgB,yCAAyC,CACvD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,6CAA6C,CAAC,GACnE,mCAAmC,CAGrC;AAED;;;;GAIG;AACH,wBAAgB,2CAA2C,CACzD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,+CAA+C,CAAC,GACrE,qCAAqC,CAMvC"}

package/dist/modules/catalog-admission/src/machine-admission.js

@@ -1,15 +1,15 @@
-import { compareCanonicalStrings, DIGEST_PATTERN, digest, IDENTIFIER_PATTERN, } from "provenry/primitives";
+import { DIGEST_PATTERN, digest, IDENTIFIER_PATTERN } from "provenry/primitives";
 import { z } from "zod";
 import { evidenceCaptureMethodSchema } from "../../../contracts/evidence/src/index.js";
-import { assertCurrentCoveragePolicyClaimClosure, coveragePolicyCoreSchema, coveragePolicySchema, } from "../../../contracts/policies/src/index.js";
-import { catalogRevisionContracts, entityRevisionSchema, offerRevisionSchema, programRevisionSchema, } from "../../../contracts/revisions/src/index.js";
+import { coveragePolicySchema } from "../../../contracts/policies/src/index.js";
+import { entityRevisionSchema, offerRevisionSchema, programRevisionSchema, } from "../../../contracts/revisions/src/index.js";
 import { ENTITY_ID_PATTERN, OFFER_ID_PATTERN, PROGRAM_ID_PATTERN, } from "../../catalog-primitives/src/index.js";
-import { deriveMaterialClaimPlan, materialClaimPlanSchema, materialClaimResultSchema, verifyMaterialClaimEvaluation, } from "../../provenance/src/index.js";
+import { materialClaimPlanSchema, materialClaimResultSchema } from "../../provenance/src/index.js";
 const digestSchema = z.string().regex(DIGEST_PATTERN);
 const identifierSchema = z.string().regex(IDENTIFIER_PATTERN);
 const gitObjectSchema = z.string().regex(/^[a-f0-9]{40,64}$/u);
 const repositorySchema = z.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u);
-const entityPathSchema = z
+export const entityPathSchema = z
     .string()
     .regex(/^entities\/[a-z0-9]{2}\/[a-z0-9]+(?:-[a-z0-9]+)*\.yaml$/u);
 export const startupCreditsMachineAdmissionPolicyCoreSchema = z
@@ -345,330 +345,4 @@ export function createStartupCreditsAdmissionCandidateInput(input) {
         candidate_digest: digest(core),
     });
 }
-export function createStartupCreditsMachineAdmissionPolicy(input) {
-    const core = startupCreditsMachineAdmissionPolicyCoreSchema.parse(input);
-    return startupCreditsMachineAdmissionPolicySchema.parse({
-        ...core,
-        policy_digest: digest(core),
-    });
-}
-/** One total pure policy over exact, already verified domain results. */
-export function evaluateStartupCreditsMachineAdmission(input) {
-    const parsed = startupCreditsMachineAdmissionInputSchema.parse(input);
-    const { input_digest: inputDigest, ...inputCore } = parsed;
-    if (digest(startupCreditsMachineAdmissionInputCoreSchema.parse(inputCore)) !== inputDigest) {
-        throw new Error("Startup Credits machine-admission input digest does not match its content.");
-    }
-    const { evaluations, reasons, outcome } = evaluateAdmissionCandidatePolicy(parsed);
-    const resultCore = startupCreditsMachineAdmissionResultCoreSchema.parse({
-        result_contract: "sourcey.startup-credits-machine-admission-result/v1alpha1",
-        input_digest: inputDigest,
-        outcome,
-        reason_codes: reasons,
-        retryable: outcome === "temporarily_unavailable",
-        claim_plan_digests: evaluations
-            .map(({ plan }) => plan.plan_digest)
-            .sort(compareCanonicalStrings),
-        claim_result_digests: evaluations
-            .flatMap(({ results }) => results.map(({ result_digest: resultDigest }) => resultDigest))
-            .sort(compareCanonicalStrings),
-    });
-    const result = startupCreditsMachineAdmissionResultSchema.parse({
-        ...resultCore,
-        result_digest: digest(resultCore),
-    });
-    const receiptCore = startupCreditsMachineAdmissionReceiptCoreSchema.parse({
-        receipt_contract: "sourcey.startup-credits-machine-admission-receipt/v1alpha1",
-        input_digest: inputDigest,
-        result_digest: result.result_digest,
-        policy_id: parsed.policy.policy_id,
-        policy_digest: parsed.policy.policy_digest,
-        evaluator_id: parsed.evaluator_id,
-        evaluator_digest: parsed.evaluator_digest,
-    });
-    const receipt = startupCreditsMachineAdmissionReceiptSchema.parse({
-        ...receiptCore,
-        receipt_digest: digest(receiptCore),
-    });
-    return {
-        input: parsed,
-        result,
-        receipt,
-        decisionBasis: {
-            kind: "policy",
-            policy_id: parsed.policy.policy_id,
-            policy_digest: parsed.policy.policy_digest,
-            evaluator_id: parsed.evaluator_id,
-            evaluator_digest: parsed.evaluator_digest,
-            input_digest: parsed.input_digest,
-            execution_receipt_digest: receipt.receipt_digest,
-        },
-    };
-}
-/**
- * The shared deterministic admission verdict used by transport-specific
- * applications. This emits no publication, payment, Git or reviewer authority.
- */
-export function evaluateStartupCreditsAdmissionCandidate(input) {
-    const parsed = startupCreditsAdmissionCandidateInputSchema.parse(input);
-    const { candidate_digest: candidateDigest, ...inputCore } = parsed;
-    if (digest(startupCreditsAdmissionCandidateInputCoreSchema.parse(inputCore)) !== candidateDigest) {
-        throw new Error("Startup Credits admission candidate digest does not match its content.");
-    }
-    const { evaluations, reasons, outcome } = evaluateAdmissionCandidatePolicy(parsed);
-    const resultCore = startupCreditsAdmissionCandidateResultCoreSchema.parse({
-        result_contract: "sourcey.startup-credits-admission-candidate-result/v1alpha1",
-        candidate_digest: candidateDigest,
-        outcome,
-        reason_codes: reasons,
-        retryable: outcome === "temporarily_unavailable",
-        claim_plan_digests: evaluations
-            .map(({ plan }) => plan.plan_digest)
-            .sort(compareCanonicalStrings),
-        claim_result_digests: evaluations
-            .flatMap(({ results }) => results.map(({ result_digest: resultDigest }) => resultDigest))
-            .sort(compareCanonicalStrings),
-    });
-    const result = startupCreditsAdmissionCandidateResultSchema.parse({
-        ...resultCore,
-        result_digest: digest(resultCore),
-    });
-    const receiptCore = startupCreditsAdmissionCandidateReceiptCoreSchema.parse({
-        receipt_contract: "sourcey.startup-credits-admission-candidate-receipt/v1alpha1",
-        candidate_digest: candidateDigest,
-        result_digest: result.result_digest,
-        policy_id: parsed.policy.policy_id,
-        policy_digest: parsed.policy.policy_digest,
-        evaluator_id: parsed.evaluator_id,
-        evaluator_digest: parsed.evaluator_digest,
-    });
-    const receipt = startupCreditsAdmissionCandidateReceiptSchema.parse({
-        ...receiptCore,
-        receipt_digest: digest(receiptCore),
-    });
-    return {
-        input: parsed,
-        result,
-        receipt,
-        decisionBasis: {
-            kind: "policy",
-            policy_id: parsed.policy.policy_id,
-            policy_digest: parsed.policy.policy_digest,
-            evaluator_id: parsed.evaluator_id,
-            evaluator_digest: parsed.evaluator_digest,
-            input_digest: parsed.candidate_digest,
-            execution_receipt_digest: receipt.receipt_digest,
-        },
-    };
-}
-function evaluateAdmissionCandidatePolicy(input) {
-    verifyAdmissionPolicies(input);
-    const evaluations = input.claim_evaluations.map((evaluation) => verifyMaterialClaimEvaluation(evaluation));
-    assertClosedEvaluationInput(input, evaluations);
-    const reasons = evaluateReasons(input, evaluations);
-    return { evaluations, reasons, outcome: outcomeForReasons(reasons) };
-}
-function assertClosedEvaluationInput(input, evaluations) {
-    const sources = new Map(input.sources.map((source) => [sourceKey(source), source]));
-    if (sources.size !== input.sources.length) {
-        throw new Error("Machine-admission sources must be unique by subject revision and source_id.");
-    }
-    const planSubjects = evaluations.map(({ plan }) => subjectKey(plan));
-    const changedSubjects = input.changed_subjects
-        .filter(({ change }) => change !== "removed")
-        .map(subjectKeyFromChange);
-    if (new Set(planSubjects).size !== planSubjects.length ||
-        [...planSubjects].sort().join("\0") !== [...changedSubjects].sort().join("\0")) {
-        throw new Error("Material claim plans do not close the exact changed subject revisions.");
-    }
-    const revisions = new Map(input.candidate_revisions.map((revision) => [subjectKeyFromRevision(revision), revision]));
-    if (revisions.size !== input.candidate_revisions.length ||
-        [...revisions.keys()].sort().join("\0") !== [...changedSubjects].sort().join("\0")) {
-        throw new Error("Candidate revisions do not close the exact changed subject revisions.");
-    }
-    for (const evaluation of evaluations) {
-        const revision = revisions.get(subjectKey(evaluation.plan));
-        if (!revision)
-            throw new Error("Material claim plan has no exact candidate revision.");
-        const derived = deriveMaterialClaimPlan({
-            revision,
-            requirements: revision.revision_contract === catalogRevisionContracts.entity
-                ? input.coverage_policy.entity_requirements
-                : revision.revision_contract === catalogRevisionContracts.program
-                    ? input.coverage_policy.program_requirements
-                    : input.coverage_policy.offer_requirements,
-            coveragePolicyDigest: input.coverage_policy.policy_digest,
-        });
-        if (derived.plan_digest !== evaluation.plan.plan_digest) {
-            throw new Error("Material claim plan is not the exact derivation of its candidate revision.");
-        }
-    }
-    for (const { plan, results } of evaluations) {
-        for (const result of results) {
-            for (const binding of result.bindings) {
-                const source = sources.get(sourceKey({
-                    subject_revision_digest: plan.subject.revision_digest,
-                    source_id: binding.source_id,
-                }));
-                if (!source)
-                    throw new Error(`Material claim binding names unknown source ${binding.source_id}.`);
-                if (source.capture_status !== "captured" ||
-                    source.capture_digest !== binding.capture_digest ||
-                    source.normalized_object_digest !== binding.normalized_object_digest) {
-                    throw new Error("Material claim binding differs from its exact captured source objects.");
-                }
-            }
-        }
-    }
-}
-function verifyAdmissionPolicies(input) {
-    const { policy_digest: policyDigest, ...policyCore } = input.policy;
-    if (digest(startupCreditsMachineAdmissionPolicyCoreSchema.parse(policyCore)) !== policyDigest) {
-        throw new Error("Machine-admission policy is not content-addressed correctly.");
-    }
-    const coveragePolicy = assertCurrentCoveragePolicyClaimClosure(input.coverage_policy);
-    const { policy_digest: coverageDigest, ...coverageCore } = coveragePolicy;
-    if (digest(coveragePolicyCoreSchema.parse(coverageCore)) !== coverageDigest ||
-        input.policy.coverage_policy_digest !== coverageDigest) {
-        throw new Error("Machine-admission policy does not bind the exact current coverage policy.");
-    }
-}
-function evaluateReasons(input, evaluations) {
-    const reasons = new Set();
-    if (input.changed_files.length !== 1 ||
-        input.changed_files[0]?.change !== "added" ||
-        !entityPathSchema.safeParse(input.changed_files[0]?.path).success) {
-        reasons.add("scope_requires_one_added_entity_file");
-    }
-    const entities = input.changed_subjects.filter(({ kind }) => kind === "entity");
-    const programs = input.changed_subjects.filter(({ kind }) => kind === "program");
-    const offers = input.changed_subjects.filter(({ kind }) => kind === "offer");
-    if (entities.length !== 1 || entities[0]?.change !== "added") {
-        reasons.add("scope_requires_one_new_entity");
-    }
-    if (programs.length > 1 || programs.some(({ change }) => change !== "added")) {
-        reasons.add("scope_requires_zero_or_one_new_program");
-    }
-    if (offers.length !== 1 || offers[0]?.change !== "added") {
-        reasons.add("scope_requires_one_new_offer");
-    }
-    if (offers.some((offer) => offer.kind === "offer" && offer.evidence_basis === "declared")) {
-        reasons.add("declared_offer_not_machine_admissible");
-    }
-    const entityPlan = evaluations.find(({ plan }) => plan.subject.subject_type === "entity")?.plan;
-    if (!entityPlan?.claims.some(({ path }) => path === "/summary")) {
-        reasons.add("entity_summary_required");
-    }
-    const programPlan = evaluations.find(({ plan }) => plan.subject.subject_type === "program")?.plan;
-    if (programs.length === 1 && !programPlan?.claims.some(({ path }) => path === "/summary")) {
-        reasons.add("program_summary_required");
-    }
-    for (const source of input.sources) {
-        if (source.capture_status === "retryable_failure")
-            reasons.add("source_capture_retryable");
-        if (source.capture_status === "terminal_failure")
-            reasons.add("source_capture_failed");
-        if (source.capture_status === "anomaly")
-            reasons.add("source_capture_anomaly");
-        if (source.response_status_code !== null &&
-            (source.response_status_code < 200 || source.response_status_code >= 300)) {
-            reasons.add("source_http_status_not_success");
-        }
-        if (source.availability === "restricted")
-            reasons.add("source_not_public");
-        if (source.capture_method !== null &&
-            source.capture_method !== "http" &&
-            source.capture_method !== "headless") {
-            reasons.add("capture_method_not_unattended");
-        }
-        if (source.authority === "ambiguous")
-            reasons.add("source_authority_ambiguous");
-    }
-    const sources = new Map(input.sources.map((source) => [sourceKey(source), source]));
-    for (const { plan, results } of evaluations) {
-        for (const result of results) {
-            if (result.status === "unsupported")
-                reasons.add("claim_unsupported");
-            if (result.status === "unresolved")
-                reasons.add("claim_unresolved");
-            if (result.status === "contradicted")
-                reasons.add("claim_contradicted");
-            if (result.status === "supported" &&
-                result.bindings.some((binding) => sources.get(sourceKey({
-                    subject_revision_digest: plan.subject.revision_digest,
-                    source_id: binding.source_id,
-                }))?.authority !== "canonical")) {
-                reasons.add("supported_claim_uses_inert_source");
-            }
-        }
-    }
-    for (const conflict of input.conflicts) {
-        reasons.add(conflict.strength === "exact" ? "exact_conflict" : "ambiguous_conflict");
-    }
-    if (input.asset.kind === "vendor_asset" && input.asset.status !== "supported") {
-        reasons.add("vendor_asset_requires_authority_review");
-    }
-    else if (input.asset.status !== "supported" || input.asset.candidate_digest === null) {
-        reasons.add("safe_asset_required");
-    }
-    return [...reasons].sort(compareCanonicalStrings);
-}
-function outcomeForReasons(reasons) {
-    if (reasons.some((reason) => [
-        "declared_offer_not_machine_admissible",
-        "source_capture_anomaly",
-        "source_http_status_not_success",
-        "source_not_public",
-        "supported_claim_uses_inert_source",
-        "exact_conflict",
-    ].includes(reason))) {
-        return "rejected";
-    }
-    if (reasons.includes("source_capture_retryable"))
-        return "temporarily_unavailable";
-    if (reasons.some((reason) => [
-        "source_authority_ambiguous",
-        "capture_method_not_unattended",
-        "claim_unresolved",
-        "ambiguous_conflict",
-        "vendor_asset_requires_authority_review",
-    ].includes(reason))) {
-        return "human_review_required";
-    }
-    if (reasons.length > 0)
-        return "needs_revision";
-    return "auto_admissible";
-}
-function subjectKey(plan) {
-    return `${subjectIdentity(plan.subject)}\0${plan.subject.revision_digest}`;
-}
-function subjectKeyFromChange(subject) {
-    if (subject.revision_digest === null)
-        throw new Error("A non-removed changed subject needs a revision.");
-    return `${subjectIdentity(subject)}\0${subject.revision_digest}`;
-}
-function subjectKeyFromRevision(revision) {
-    const subject = revision.revision_contract === catalogRevisionContracts.entity
-        ? { kind: "entity", entity_id: revision.entity_id }
-        : revision.revision_contract === catalogRevisionContracts.program
-            ? {
-                kind: "program",
-                entity_id: revision.entity_id,
-                program_id: revision.program_id,
-            }
-            : {
-                kind: "offer",
-                entity_id: revision.entity_id,
-                program_id: revision.program_id,
-                offer_id: revision.offer_id,
-            };
-    return `${subjectIdentity(subject)}\0${revision.revision_digest}`;
-}
-function subjectIdentity(subject) {
-    const kind = subject.kind ?? subject.subject_type;
-    return `${kind}\0${subject.entity_id}\0${subject.program_id ?? ""}\0${subject.offer_id ?? ""}`;
-}
-function sourceKey(source) {
-    return `${source.subject_revision_digest}\0${source.source_id}`;
-}
 //# sourceMappingURL=machine-admission.js.map