@nakafa/aksara-contracts 0.27.0

package/dist/tryout/runtime/spec.d.ts

@@ -0,0 +1,58 @@
+import { Schema } from "effect";
+/** Stable wire format for one permanent signed try-out runtime bundle. */
+export declare const TRYOUT_RUNTIME_BUNDLE_FORMAT = "signed-tryout-runtime-bundle";
+/** Source and runtime facts authenticated independently from a global release. */
+export declare const TryoutRuntimeBundlePayloadSchema: Schema.Struct<{
+    readonly format: Schema.Literal<"signed-tryout-runtime-bundle">;
+    readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly snapshot: Schema.Struct<{
+        readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+        readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly counts: Schema.Struct<{
+            readonly country: Schema.Int;
+            readonly exam: Schema.Int;
+            readonly section: Schema.Int;
+            readonly set: Schema.Int;
+            readonly track: Schema.Int;
+        }>;
+        readonly placementCount: Schema.Int;
+        readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly routeCount: Schema.Int;
+        readonly format: Schema.Literal<"localized-tryout-snapshot">;
+        readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>;
+    readonly sourceGitSha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+    readonly sourceManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourceReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type TryoutRuntimeBundlePayload = typeof TryoutRuntimeBundlePayloadSchema.Type;
+/** Immutable bundle identity plus its Ed25519 authenticity proof. */
+export declare const SignedTryoutRuntimeBundleSchema: Schema.Struct<{
+    readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+    readonly payload: Schema.Struct<{
+        readonly format: Schema.Literal<"signed-tryout-runtime-bundle">;
+        readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly snapshot: Schema.Struct<{
+            readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+            readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly counts: Schema.Struct<{
+                readonly country: Schema.Int;
+                readonly exam: Schema.Int;
+                readonly section: Schema.Int;
+                readonly set: Schema.Int;
+                readonly track: Schema.Int;
+            }>;
+            readonly placementCount: Schema.Int;
+            readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly routeCount: Schema.Int;
+            readonly format: Schema.Literal<"localized-tryout-snapshot">;
+            readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        }>;
+        readonly sourceGitSha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+        readonly sourceManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly sourceReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    }>;
+    readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+}>;
+export type SignedTryoutRuntimeBundle = typeof SignedTryoutRuntimeBundleSchema.Type;

package/dist/tryout/runtime/spec.js

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+import { Ed25519SignatureSchema, GitCommitShaSchema, ReleaseIdSchema, Sha256HashSchema, SigningKeyIdSchema, } from "#contracts/ids";
+import { TryoutSnapshotSchema } from "#contracts/tryout/snapshot/spec";
+/** Stable wire format for one permanent signed try-out runtime bundle. */
+export const TRYOUT_RUNTIME_BUNDLE_FORMAT = "signed-tryout-runtime-bundle";
+/** Source and runtime facts authenticated independently from a global release. */
+export const TryoutRuntimeBundlePayloadSchema = Schema.Struct({
+    format: Schema.Literal(TRYOUT_RUNTIME_BUNDLE_FORMAT),
+    rendererManifestHash: Sha256HashSchema,
+    snapshot: TryoutSnapshotSchema,
+    sourceGitSha: GitCommitShaSchema,
+    sourceManifestHash: Sha256HashSchema,
+    sourceReleaseId: ReleaseIdSchema,
+});
+/** Immutable bundle identity plus its Ed25519 authenticity proof. */
+export const SignedTryoutRuntimeBundleSchema = Schema.Struct({
+    bundleHash: Sha256HashSchema,
+    keyId: SigningKeyIdSchema,
+    payload: TryoutRuntimeBundlePayloadSchema,
+    signature: Ed25519SignatureSchema,
+});

package/dist/tryout/runtime/verify.d.ts

@@ -0,0 +1,61 @@
+import { Effect, Schema } from "effect";
+declare const TryoutRuntimeBundleVerificationDecodeError_base: Schema.Class<TryoutRuntimeBundleVerificationDecodeError, Schema.TaggedStruct<"TryoutRuntimeBundleVerificationDecodeError", {
+    readonly message: Schema.Literal<"Try-out runtime bundle verification input does not satisfy its exact wire contract.">;
+}>, import("effect/Cause").YieldableError>;
+/** Unknown input did not exactly satisfy the signed runtime-bundle contract. */
+export declare class TryoutRuntimeBundleVerificationDecodeError extends TryoutRuntimeBundleVerificationDecodeError_base {
+}
+declare const TryoutRuntimeBundleHashMismatchError_base: Schema.Class<TryoutRuntimeBundleHashMismatchError, Schema.TaggedStruct<"TryoutRuntimeBundleHashMismatchError", {
+    readonly actualHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly expectedHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, import("effect/Cause").YieldableError>;
+/** The envelope hash does not identify its complete canonical payload. */
+export declare class TryoutRuntimeBundleHashMismatchError extends TryoutRuntimeBundleHashMismatchError_base {
+}
+declare const TryoutRuntimeBundleSnapshotMismatchError_base: Schema.Class<TryoutRuntimeBundleSnapshotMismatchError, Schema.TaggedStruct<"TryoutRuntimeBundleSnapshotMismatchError", {
+    readonly actualSnapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly expectedSnapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, import("effect/Cause").YieldableError>;
+/** The embedded snapshot identity does not match its semantic facts. */
+export declare class TryoutRuntimeBundleSnapshotMismatchError extends TryoutRuntimeBundleSnapshotMismatchError_base {
+}
+declare const TryoutRuntimeBundleRendererMismatchError_base: Schema.Class<TryoutRuntimeBundleRendererMismatchError, Schema.TaggedStruct<"TryoutRuntimeBundleRendererMismatchError", {
+    readonly actualRendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly expectedRendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, import("effect/Cause").YieldableError>;
+/** The supplied renderer is not the renderer authenticated by the bundle. */
+export declare class TryoutRuntimeBundleRendererMismatchError extends TryoutRuntimeBundleRendererMismatchError_base {
+}
+/** Strictly decodes and authenticates a renderer-bound runtime bundle. */
+export declare const verifySignedTryoutRuntimeBundle: (input: {
+    readonly bundle: unknown;
+    readonly rendererManifest: unknown;
+}) => Effect.Effect<{
+    readonly bundleHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly keyId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSigningKeyId">;
+    readonly payload: {
+        readonly format: "signed-tryout-runtime-bundle";
+        readonly rendererManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly snapshot: {
+            readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+            readonly catalogDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            readonly counts: {
+                readonly country: number;
+                readonly exam: number;
+                readonly section: number;
+                readonly set: number;
+                readonly track: number;
+            };
+            readonly placementCount: number;
+            readonly placementDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            readonly routeCount: number;
+            readonly format: "localized-tryout-snapshot";
+            readonly snapshotId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        };
+        readonly sourceGitSha: string & import("effect/Brand").Brand<"@NakafaAI/AksaraGitCommitSha">;
+        readonly sourceManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly sourceReleaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+    };
+    readonly signature: string & import("effect/Brand").Brand<"@NakafaAI/AksaraEd25519Signature">;
+}, import("../../errors.js").ContractDecodeError | import("../../signature/spec.js").PublicKeyParseError | import("../../signature/spec.js").PublicKeyTypeError | import("../../renderer/component.js").RendererAuthoringComponentDuplicateError | import("../../renderer/component.js").RendererAuthoringComponentExtraError | import("../../renderer/component.js").RendererAuthoringComponentMissingError | import("../../renderer/component.js").RendererAuthoringComponentUnsupportedError | import("../../renderer/component.js").RendererAuthoringSelectionNonCanonicalError | import("../../renderer/contract.js").RendererManifestHashComputeError | import("../../renderer/contract.js").RendererManifestHashMismatchError | import("../../signature/spec.js").SignatureCheckError | import("../../signature/spec.js").SignatureInvalidError | import("../../signature/spec.js").SigningKeyNotFoundError | import("../../signature/spec.js").SigningKeyResolutionError | import("#contracts/tryout/runtime/hash").TryoutRuntimeBundleHashComputationError | TryoutRuntimeBundleHashMismatchError | TryoutRuntimeBundleRendererMismatchError | TryoutRuntimeBundleSnapshotMismatchError | TryoutRuntimeBundleVerificationDecodeError, import("../../signature/spec.js").ContentVerificationKeyResolver>;
+export {};

package/dist/tryout/runtime/verify.js

@@ -0,0 +1,69 @@
+import { Effect, Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { validateRendererManifestHash } from "#contracts/renderer/manifest";
+import { verifyEd25519Signature } from "#contracts/signature/verify";
+import { canonicalizeTryoutRuntimeBundleSigningInput } from "#contracts/tryout/runtime/canonical";
+import { hashTryoutRuntimeBundlePayload } from "#contracts/tryout/runtime/hash";
+import { SignedTryoutRuntimeBundleSchema, } from "#contracts/tryout/runtime/spec";
+import { makeTryoutSnapshot } from "#contracts/tryout/snapshot/hash";
+/** Unknown input did not exactly satisfy the signed runtime-bundle contract. */
+export class TryoutRuntimeBundleVerificationDecodeError extends Schema.TaggedError()("TryoutRuntimeBundleVerificationDecodeError", {
+    message: Schema.Literal("Try-out runtime bundle verification input does not satisfy its exact wire contract."),
+}) {
+}
+/** The envelope hash does not identify its complete canonical payload. */
+export class TryoutRuntimeBundleHashMismatchError extends Schema.TaggedError()("TryoutRuntimeBundleHashMismatchError", {
+    actualHash: Sha256HashSchema,
+    expectedHash: Sha256HashSchema,
+}) {
+}
+/** The embedded snapshot identity does not match its semantic facts. */
+export class TryoutRuntimeBundleSnapshotMismatchError extends Schema.TaggedError()("TryoutRuntimeBundleSnapshotMismatchError", {
+    actualSnapshotId: Sha256HashSchema,
+    expectedSnapshotId: Sha256HashSchema,
+}) {
+}
+/** The supplied renderer is not the renderer authenticated by the bundle. */
+export class TryoutRuntimeBundleRendererMismatchError extends Schema.TaggedError()("TryoutRuntimeBundleRendererMismatchError", {
+    actualRendererManifestHash: Sha256HashSchema,
+    expectedRendererManifestHash: Sha256HashSchema,
+}) {
+}
+/** Authenticates one already decoded permanent try-out runtime bundle. */
+const authenticateTryoutRuntimeBundle = Effect.fn("AksaraContracts.authenticateTryoutRuntimeBundle")(function* (bundle, rendererManifest) {
+    const renderer = yield* validateRendererManifestHash(rendererManifest);
+    const actualHash = yield* hashTryoutRuntimeBundlePayload(bundle.payload);
+    if (actualHash !== bundle.bundleHash) {
+        return yield* new TryoutRuntimeBundleHashMismatchError({
+            actualHash,
+            expectedHash: bundle.bundleHash,
+        });
+    }
+    const expectedSnapshotId = makeTryoutSnapshot(bundle.payload.snapshot).snapshotId;
+    if (expectedSnapshotId !== bundle.payload.snapshot.snapshotId) {
+        return yield* new TryoutRuntimeBundleSnapshotMismatchError({
+            actualSnapshotId: bundle.payload.snapshot.snapshotId,
+            expectedSnapshotId,
+        });
+    }
+    if (renderer.hash !== bundle.payload.rendererManifestHash) {
+        return yield* new TryoutRuntimeBundleRendererMismatchError({
+            actualRendererManifestHash: renderer.hash,
+            expectedRendererManifestHash: bundle.payload.rendererManifestHash,
+        });
+    }
+    yield* verifyEd25519Signature({
+        keyId: bundle.keyId,
+        message: canonicalizeTryoutRuntimeBundleSigningInput(bundle.bundleHash, bundle.payload),
+        signature: bundle.signature,
+        subject: "tryout-runtime-bundle",
+    });
+    return bundle;
+});
+/** Strictly decodes and authenticates a renderer-bound runtime bundle. */
+export const verifySignedTryoutRuntimeBundle = Effect.fn("AksaraContracts.verifySignedTryoutRuntimeBundle")(function* (input) {
+    const bundle = yield* Schema.decodeUnknownEffect(SignedTryoutRuntimeBundleSchema)(input.bundle, { onExcessProperty: "error" }).pipe(Effect.mapError(() => new TryoutRuntimeBundleVerificationDecodeError({
+        message: "Try-out runtime bundle verification input does not satisfy its exact wire contract.",
+    })));
+    return yield* authenticateTryoutRuntimeBundle(bundle, input.rendererManifest);
+});

package/dist/tryout/snapshot/canonical.d.ts

@@ -0,0 +1,7 @@
+import type { TryoutSnapshotFacts } from "#contracts/tryout/snapshot/spec";
+/** Domain separating snapshot identities from every other try-out digest. */
+export declare const TRYOUT_SNAPSHOT_DOMAIN = "nakafa.aksara.localized-tryout-snapshot";
+/** Domain separating joined row evidence from individual row digests. */
+export declare const TRYOUT_SNAPSHOT_ROWS_DOMAIN = "nakafa.aksara.tryout-rows";
+/** Serializes snapshot facts without content-addressed identity. */
+export declare function canonicalizeTryoutSnapshot(input: TryoutSnapshotFacts): string;

package/dist/tryout/snapshot/canonical.js

@@ -0,0 +1,17 @@
+import { TRYOUT_SNAPSHOT_FORMAT } from "#contracts/tryout/snapshot/spec";
+/** Domain separating snapshot identities from every other try-out digest. */
+export const TRYOUT_SNAPSHOT_DOMAIN = "nakafa.aksara.localized-tryout-snapshot";
+/** Domain separating joined row evidence from individual row digests. */
+export const TRYOUT_SNAPSHOT_ROWS_DOMAIN = "nakafa.aksara.tryout-rows";
+/** Serializes snapshot facts without content-addressed identity. */
+export function canonicalizeTryoutSnapshot(input) {
+    return JSON.stringify({
+        activeAppLocales: input.activeAppLocales,
+        catalogDigest: input.catalogDigest,
+        counts: input.counts,
+        format: TRYOUT_SNAPSHOT_FORMAT,
+        placementCount: input.placementCount,
+        placementDigest: input.placementDigest,
+        routeCount: input.routeCount,
+    });
+}

package/dist/tryout/snapshot/hash.d.ts

@@ -0,0 +1,8 @@
+import { type TryoutSnapshot, type TryoutSnapshotFacts } from "#contracts/tryout/snapshot/spec";
+/** Creates one complete content-addressed try-out snapshot. */
+export declare function makeTryoutSnapshot(input: TryoutSnapshotFacts): TryoutSnapshot;
+/** Returns exact structured row evidence authenticated by a snapshot. */
+export declare function tryoutSnapshotRowEvidence(input: TryoutSnapshotFacts): {
+    rowCount: number;
+    rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+};

package/dist/tryout/snapshot/hash.js

@@ -0,0 +1,19 @@
+import { hashTryoutCanonical } from "#contracts/tryout/canonical";
+import { canonicalizeTryoutSnapshot, TRYOUT_SNAPSHOT_DOMAIN, TRYOUT_SNAPSHOT_ROWS_DOMAIN, } from "#contracts/tryout/snapshot/canonical";
+import { TRYOUT_SNAPSHOT_FORMAT, TryoutSnapshotSchema, } from "#contracts/tryout/snapshot/spec";
+/** Creates one complete content-addressed try-out snapshot. */
+export function makeTryoutSnapshot(input) {
+    return TryoutSnapshotSchema.make({
+        ...input,
+        format: TRYOUT_SNAPSHOT_FORMAT,
+        snapshotId: hashTryoutCanonical(TRYOUT_SNAPSHOT_DOMAIN, canonicalizeTryoutSnapshot(input)),
+    });
+}
+/** Returns exact structured row evidence authenticated by a snapshot. */
+export function tryoutSnapshotRowEvidence(input) {
+    return {
+        rowCount: Object.values(input.counts).reduce((total, count) => total + count, 0) +
+            input.placementCount,
+        rowDigest: hashTryoutCanonical(TRYOUT_SNAPSHOT_ROWS_DOMAIN, `${input.catalogDigest}\n${input.placementDigest}`),
+    };
+}

package/dist/tryout/snapshot/spec.d.ts

@@ -0,0 +1,46 @@
+import { Schema } from "effect";
+/** Semantic wire identity of the current localized try-out snapshot. */
+export declare const TRYOUT_SNAPSHOT_FORMAT = "localized-tryout-snapshot";
+/** Signed per-kind hierarchy counts for one immutable try-out snapshot. */
+export declare const TryoutCatalogCountsSchema: Schema.Struct<{
+    readonly country: Schema.Int;
+    readonly exam: Schema.Int;
+    readonly section: Schema.Int;
+    readonly set: Schema.Int;
+    readonly track: Schema.Int;
+}>;
+export type TryoutCatalogCounts = typeof TryoutCatalogCountsSchema.Type;
+/** Canonical snapshot facts authenticated by the global content release. */
+export declare const TryoutSnapshotFactsSchema: Schema.Struct<{
+    activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+    catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    counts: Schema.Struct<{
+        readonly country: Schema.Int;
+        readonly exam: Schema.Int;
+        readonly section: Schema.Int;
+        readonly set: Schema.Int;
+        readonly track: Schema.Int;
+    }>;
+    placementCount: Schema.Int;
+    placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    routeCount: Schema.Int;
+}>;
+export type TryoutSnapshotFacts = typeof TryoutSnapshotFactsSchema.Type;
+/** Content-addressed try-out snapshot selected by one global release. */
+export declare const TryoutSnapshotSchema: Schema.Struct<{
+    readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+    readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly counts: Schema.Struct<{
+        readonly country: Schema.Int;
+        readonly exam: Schema.Int;
+        readonly section: Schema.Int;
+        readonly set: Schema.Int;
+        readonly track: Schema.Int;
+    }>;
+    readonly placementCount: Schema.Int;
+    readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly routeCount: Schema.Int;
+    readonly format: Schema.Literal<"localized-tryout-snapshot">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>;
+export type TryoutSnapshot = typeof TryoutSnapshotSchema.Type;

package/dist/tryout/snapshot/spec.js

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { ActiveAppLocaleListSchema } from "#contracts/locale";
+/** Semantic wire identity of the current localized try-out snapshot. */
+export const TRYOUT_SNAPSHOT_FORMAT = "localized-tryout-snapshot";
+const NonNegativeCountSchema = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** Signed per-kind hierarchy counts for one immutable try-out snapshot. */
+export const TryoutCatalogCountsSchema = Schema.Struct({
+    country: NonNegativeCountSchema,
+    exam: NonNegativeCountSchema,
+    section: NonNegativeCountSchema,
+    set: NonNegativeCountSchema,
+    track: NonNegativeCountSchema,
+});
+const TryoutSnapshotFactFields = {
+    activeAppLocales: ActiveAppLocaleListSchema,
+    catalogDigest: Sha256HashSchema,
+    counts: TryoutCatalogCountsSchema,
+    placementCount: NonNegativeCountSchema,
+    placementDigest: Sha256HashSchema,
+    routeCount: NonNegativeCountSchema,
+};
+/** Canonical snapshot facts authenticated by the global content release. */
+export const TryoutSnapshotFactsSchema = Schema.Struct(TryoutSnapshotFactFields);
+/** Content-addressed try-out snapshot selected by one global release. */
+export const TryoutSnapshotSchema = Schema.Struct({
+    ...TryoutSnapshotFactFields,
+    format: Schema.Literal(TRYOUT_SNAPSHOT_FORMAT),
+    snapshotId: Sha256HashSchema,
+});

package/dist/tryout/spec.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+/** Scoring model selected by one authored exam. */
+export declare const TryoutScoringSchema: Schema.Literals<readonly ["irt", "raw"]>;
+export type TryoutScoring = typeof TryoutScoringSchema.Type;
+/** Navigation role of one authored track. */
+export declare const TryoutTrackKindSchema: Schema.Literals<readonly ["subject", "year"]>;
+/** Public route behavior of one authored section. */
+export declare const TryoutVisibilitySchema: Schema.Literals<readonly ["internal-entry", "visible"]>;
+/** Bounded authored revision shared by one try-out source hierarchy. */
+export declare const TryoutSourceRevisionSchema: Schema.Trimmed;
+/** Durable complete-question identity retained by every frozen placement. */
+export declare const TryoutContentHashSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraTryoutContentHash">;
+export type TryoutContentHash = typeof TryoutContentHashSchema.Type;

package/dist/tryout/spec.js

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+const TRYOUT_CONTENT_HASH_PATTERN = /^[a-f\d]{64}$/u;
+/** Scoring model selected by one authored exam. */
+export const TryoutScoringSchema = Schema.Literals(["irt", "raw"]);
+/** Navigation role of one authored track. */
+export const TryoutTrackKindSchema = Schema.Literals(["subject", "year"]);
+/** Public route behavior of one authored section. */
+export const TryoutVisibilitySchema = Schema.Literals([
+    "internal-entry",
+    "visible",
+]);
+/** Bounded authored revision shared by one try-out source hierarchy. */
+export const TryoutSourceRevisionSchema = Schema.Trimmed.check(Schema.isNonEmpty()).pipe(Schema.check(Schema.isMaxLength(128)));
+/** Durable complete-question identity retained by every frozen placement. */
+export const TryoutContentHashSchema = Schema.String.pipe(Schema.check(Schema.isPattern(TRYOUT_CONTENT_HASH_PATTERN)), Schema.brand("@NakafaAI/AksaraTryoutContentHash"));