@nakafa/aksara-contracts 0.27.0

package/dist/decode.d.ts

@@ -0,0 +1,4 @@
+import { Effect, Schema } from "effect";
+import { ContractDecodeError } from "#contracts/errors";
+/** Strictly decodes one named wire contract into the shared typed failure. */
+export declare function decodeContract<A, I>(schema: Schema.Codec<A, I>, contract: string, input: unknown): Effect.Effect<A, ContractDecodeError, never>;

package/dist/decode.js

@@ -0,0 +1,8 @@
+import { Effect, Schema } from "effect";
+import { ContractDecodeError } from "#contracts/errors";
+/** Strictly decodes one named wire contract into the shared typed failure. */
+export function decodeContract(schema, contract, input) {
+    return Schema.decodeUnknownEffect(schema)(input, {
+        onExcessProperty: "error",
+    }).pipe(Effect.mapError((cause) => new ContractDecodeError({ cause, contract, message: String(cause) })));
+}

package/dist/delivery.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+/** Access boundary enforced before any published artifact body is returned. */
+export declare const ContentDeliveryClassSchema: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+export type ContentDeliveryClass = typeof ContentDeliveryClassSchema.Type;

package/dist/delivery.js

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+/** Access boundary enforced before any published artifact body is returned. */
+export const ContentDeliveryClassSchema = Schema.Literals([
+    "public",
+    "authenticated",
+    "entitled",
+]);

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+declare const ContractDecodeError_base: Schema.Class<ContractDecodeError, Schema.TaggedStruct<"ContractDecodeError", {
+    readonly cause: Schema.Unknown;
+    readonly contract: Schema.Trimmed;
+    readonly message: Schema.Trimmed;
+}>, import("effect/Cause").YieldableError>;
+/** Describes a wire value that failed its named Effect Schema contract. */
+export declare class ContractDecodeError extends ContractDecodeError_base {
+}
+export {};

package/dist/errors.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+/** Describes a wire value that failed its named Effect Schema contract. */
+export class ContractDecodeError extends Schema.TaggedError()("ContractDecodeError", {
+    cause: Schema.Unknown,
+    contract: Schema.Trimmed.check(Schema.isNonEmpty()),
+    message: Schema.Trimmed.check(Schema.isNonEmpty()),
+}) {
+}

package/dist/graph/family.d.ts

@@ -0,0 +1,45 @@
+import { Effect, Schema } from "effect";
+/** Current semantic families addressable through learning-graph identities. */
+export declare const LearningGraphFamilySchema: Schema.Literals<readonly ["article", "material", "quran", "tryout"]>;
+export type LearningGraphFamily = typeof LearningGraphFamilySchema.Type;
+/** Current asset identity accepted by route and graph read-model dispatch. */
+export declare const LearningGraphAssetIdSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraLearningGraphAssetId">;
+export type LearningGraphAssetId = typeof LearningGraphAssetIdSchema.Type;
+/** Semantic owner extracted from one exact current learning-graph asset ID. */
+export declare const LearningGraphAssetOwnerSchema: Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly family: Schema.Literals<readonly ["article", "material", "quran", "tryout"]>;
+}>;
+export type LearningGraphAssetOwner = typeof LearningGraphAssetOwnerSchema.Type;
+declare const LearningGraphAssetFamilyError_base: Schema.Class<LearningGraphAssetFamilyError, Schema.TaggedStruct<"LearningGraphAssetFamilyError", {
+    readonly assetId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** One asset ID cannot address a supported current semantic content family. */
+export declare class LearningGraphAssetFamilyError extends LearningGraphAssetFamilyError_base {
+}
+declare const LearningGraphFamilyError_base: Schema.Class<LearningGraphFamilyError, Schema.TaggedStruct<"LearningGraphFamilyError", {
+    readonly identity: Schema.Struct<{
+        readonly alignmentId: Schema.String;
+        readonly assetId: Schema.String;
+        readonly conceptId: Schema.String;
+        readonly learningObjectId: Schema.String;
+        readonly lensId: Schema.String;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+/** One graph identity does not coherently belong to a current semantic family. */
+export declare class LearningGraphFamilyError extends LearningGraphFamilyError_base {
+}
+/** Classifies one assetId-only reference without fabricating a full identity. */
+export declare const classifyLearningGraphAssetId: (input: string) => Effect.Effect<{
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly family: "article" | "material" | "quran" | "tryout";
+}, LearningGraphAssetFamilyError, never>;
+/** Classifies one coherent current learning-graph identity for direct dispatch. */
+export declare const classifyLearningGraphIdentity: (identity: {
+    readonly alignmentId: string;
+    readonly assetId: string;
+    readonly conceptId: string;
+    readonly learningObjectId: string;
+    readonly lensId: string;
+}) => Effect.Effect<"article" | "material" | "quran" | "tryout", LearningGraphFamilyError, never>;
+export {};

package/dist/graph/family.js

@@ -0,0 +1,85 @@
+import { Effect, Schema } from "effect";
+import { LearningGraphIdentitySchema, LearningGraphIdSchema, } from "#contracts/graph/spec";
+import { AppLocaleCodeSchema, AppLocaleSchema } from "#contracts/locale";
+/** Current semantic families addressable through learning-graph identities. */
+export const LearningGraphFamilySchema = Schema.Literals([
+    "article",
+    "material",
+    "quran",
+    "tryout",
+]);
+/** Checks one graph ID has the exact current asset dispatch prefix and shape. */
+function hasAssetIdentityShape(assetId) {
+    const [prefix, appLocale, family, ...identity] = assetId.split(":");
+    return (prefix === "asset" &&
+        Schema.is(AppLocaleCodeSchema)(appLocale) &&
+        Schema.is(LearningGraphFamilySchema)(family) &&
+        identity.length > 0);
+}
+/** Current asset identity accepted by route and graph read-model dispatch. */
+export const LearningGraphAssetIdSchema = LearningGraphIdSchema.pipe(Schema.check(Schema.makeFilter(hasAssetIdentityShape, {
+    message: "Expected asset:<appLocale>:<family>:<identity> graph identity.",
+})), Schema.brand("@NakafaAI/AksaraLearningGraphAssetId"));
+/** Semantic owner extracted from one exact current learning-graph asset ID. */
+export const LearningGraphAssetOwnerSchema = Schema.Struct({
+    appLocale: AppLocaleSchema,
+    family: LearningGraphFamilySchema,
+});
+/** One asset ID cannot address a supported current semantic content family. */
+export class LearningGraphAssetFamilyError extends Schema.TaggedError()("LearningGraphAssetFamilyError", { assetId: Schema.String }) {
+}
+/** One graph identity does not coherently belong to a current semantic family. */
+export class LearningGraphFamilyError extends Schema.TaggedError()("LearningGraphFamilyError", { identity: LearningGraphIdentitySchema }) {
+}
+/** Returns whether an identity body belongs to one exact domain token. */
+function hasOwner(body, owner) {
+    return body === owner || body.startsWith(`${owner}:`);
+}
+/** Returns the unprefixed body of one schema-validated graph identity. */
+function identityBody(identity) {
+    const separator = identity.indexOf(":");
+    return identity.slice(separator + 1);
+}
+/** Returns whether a learning object uses its current family-owned identity. */
+function hasLearningObjectOwner(identity, family) {
+    const body = identityBody(identity.learningObjectId);
+    if (family === "article") {
+        return hasOwner(body, "article");
+    }
+    if (family === "material") {
+        return hasOwner(body, "material-section");
+    }
+    if (family === "quran") {
+        return hasOwner(body, "quran-surah");
+    }
+    return (body === "tryout" ||
+        body.startsWith("tryout-") ||
+        body.startsWith("tryout:"));
+}
+/** Verifies every graph identity field against one semantic family. */
+function hasCoherentFamily(identity, family) {
+    return (hasOwner(identityBody(identity.alignmentId), family) &&
+        hasOwner(identityBody(identity.conceptId), family) &&
+        hasLearningObjectOwner(identity, family) &&
+        hasOwner(identityBody(identity.lensId), family));
+}
+/** Classifies one assetId-only reference without fabricating a full identity. */
+export const classifyLearningGraphAssetId = Effect.fn("AksaraContracts.classifyLearningGraphAssetId")(function* (input) {
+    const [, appLocale, family] = input.split(":");
+    const owner = yield* Schema.decodeUnknownEffect(LearningGraphAssetOwnerSchema)({
+        appLocale,
+        family,
+    }).pipe(Effect.mapError(() => new LearningGraphAssetFamilyError({ assetId: input })));
+    if (!Schema.is(LearningGraphAssetIdSchema)(input)) {
+        return yield* new LearningGraphAssetFamilyError({ assetId: input });
+    }
+    return owner;
+});
+/** Classifies one coherent current learning-graph identity for direct dispatch. */
+export const classifyLearningGraphIdentity = Effect.fn("AksaraContracts.classifyLearningGraphIdentity")(function* (identity) {
+    const owner = yield* classifyLearningGraphAssetId(identity.assetId).pipe(Effect.mapError(() => new LearningGraphFamilyError({ identity })));
+    if (!hasCoherentFamily(identity, owner.family)) {
+        return yield* new LearningGraphFamilyError({ identity });
+    }
+    return owner.family;
+});

package/dist/graph/identity.d.ts

@@ -0,0 +1,19 @@
+import { Effect, Schema } from "effect";
+import { type LearningGraphIdentity } from "#contracts/graph/spec";
+/** Validated hierarchy segments required to derive one graph identity. */
+export declare const LearningGraphSegmentsSchema: Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly concept: Schema.NonEmptyArray<Schema.String>;
+    readonly learningObject: Schema.NonEmptyArray<Schema.String>;
+    readonly lens: Schema.NonEmptyArray<Schema.String>;
+}>;
+export type LearningGraphSegments = typeof LearningGraphSegmentsSchema.Type;
+declare const LearningGraphIdentityError_base: Schema.Class<LearningGraphIdentityError, Schema.TaggedStruct<"LearningGraphIdentityError", {
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+/** Source segments could not produce valid stable graph identities. */
+export declare class LearningGraphIdentityError extends LearningGraphIdentityError_base {
+}
+/** Derives all product identities from one signed route projection source. */
+export declare const makeLearningGraphIdentity: (source: LearningGraphSegments) => Effect.Effect<LearningGraphIdentity, LearningGraphIdentityError>;
+export {};

package/dist/graph/identity.js

@@ -0,0 +1,39 @@
+import { Effect, Schema } from "effect";
+import { LearningGraphIdentitySchema, } from "#contracts/graph/spec";
+import { AppLocaleSchema } from "#contracts/locale";
+import { isLowerKebab } from "#contracts/text/syntax";
+const LearningGraphSegmentSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isLowerKebab)));
+/** Validated hierarchy segments required to derive one graph identity. */
+export const LearningGraphSegmentsSchema = Schema.Struct({
+    appLocale: AppLocaleSchema,
+    concept: Schema.NonEmptyArray(LearningGraphSegmentSchema),
+    learningObject: Schema.NonEmptyArray(LearningGraphSegmentSchema),
+    lens: Schema.NonEmptyArray(LearningGraphSegmentSchema),
+});
+/** Builds one graph ID from already validated source-owned segments. */
+function graphId(prefix, segments) {
+    return `${prefix}:${segments.join(":")}`;
+}
+/** Source segments could not produce valid stable graph identities. */
+export class LearningGraphIdentityError extends Schema.TaggedError()("LearningGraphIdentityError", { cause: Schema.Unknown }) {
+}
+/** Derives all product identities from one signed route projection source. */
+export const makeLearningGraphIdentity = Effect.fn("AksaraContracts.makeLearningGraphIdentity")(function* (source) {
+    const segments = yield* Schema.decodeEffect(LearningGraphSegmentsSchema)(source, { onExcessProperty: "error" }).pipe(Effect.mapError((cause) => new LearningGraphIdentityError({
+        cause,
+    })));
+    return LearningGraphIdentitySchema.make({
+        alignmentId: graphId("alignment", [
+            ...segments.lens,
+            ...segments.learningObject,
+        ]),
+        assetId: graphId("asset", [
+            segments.appLocale,
+            ...segments.lens,
+            ...segments.learningObject,
+        ]),
+        conceptId: graphId("concept", segments.concept),
+        learningObjectId: graphId("lo", segments.learningObject),
+        lensId: graphId("lens", segments.lens),
+    });
+});

package/dist/graph/spec.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+/** Canonical colon-separated identity in Nakafa's learning graph. */
+export declare const LearningGraphIdSchema: Schema.String;
+/** Stable graph identities persisted with every route-bearing projection. */
+export declare const LearningGraphIdentitySchema: Schema.Struct<{
+    readonly alignmentId: Schema.String;
+    readonly assetId: Schema.String;
+    readonly conceptId: Schema.String;
+    readonly learningObjectId: Schema.String;
+    readonly lensId: Schema.String;
+}>;
+export type LearningGraphIdentity = typeof LearningGraphIdentitySchema.Type;
+/** Serializes graph identity fields in stable signed order. */
+export declare function canonicalizeLearningGraphIdentity(identity: LearningGraphIdentity): {
+    alignmentId: string;
+    assetId: string;
+    conceptId: string;
+    learningObjectId: string;
+    lensId: string;
+};

package/dist/graph/spec.js

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+const GRAPH_ID_PATTERN = /^(?:alignment|asset|concept|lens|lo):[a-z0-9]+(?:-[a-z0-9]+)*(?::[a-z0-9]+(?:-[a-z0-9]+)*)*$/u;
+/** Canonical colon-separated identity in Nakafa's learning graph. */
+export const LearningGraphIdSchema = Schema.String.pipe(Schema.check(Schema.isPattern(GRAPH_ID_PATTERN)));
+/** Stable graph identities persisted with every route-bearing projection. */
+export const LearningGraphIdentitySchema = Schema.Struct({
+    alignmentId: LearningGraphIdSchema,
+    assetId: LearningGraphIdSchema,
+    conceptId: LearningGraphIdSchema,
+    learningObjectId: LearningGraphIdSchema,
+    lensId: LearningGraphIdSchema,
+}).pipe(Schema.check(Schema.makeFilter(({ alignmentId, assetId, conceptId, learningObjectId, lensId }) => alignmentId.startsWith("alignment:") &&
+    assetId.startsWith("asset:") &&
+    conceptId.startsWith("concept:") &&
+    learningObjectId.startsWith("lo:") &&
+    lensId.startsWith("lens:"), { message: "Expected each graph identity to use its owned prefix." })));
+/** Serializes graph identity fields in stable signed order. */
+export function canonicalizeLearningGraphIdentity(identity) {
+    return {
+        alignmentId: identity.alignmentId,
+        assetId: identity.assetId,
+        conceptId: identity.conceptId,
+        learningObjectId: identity.learningObjectId,
+        lensId: identity.lensId,
+    };
+}

package/dist/hash/text.d.ts

@@ -0,0 +1,10 @@
+import { Effect, Schema } from "effect";
+declare const TextHashError_base: Schema.Class<TextHashError, Schema.TaggedStruct<"TextHashError", {
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+/** Web Crypto could not hash one UTF-8 contract value. */
+export declare class TextHashError extends TextHashError_base {
+}
+/** Hashes exact UTF-8 text through the Web Crypto contract. */
+export declare const hashText: (value: string) => Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, TextHashError, never>;
+export {};

package/dist/hash/text.js

@@ -0,0 +1,20 @@
+import { Effect, Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+/** Web Crypto could not hash one UTF-8 contract value. */
+export class TextHashError extends Schema.TaggedError()("TextHashError", { cause: Schema.Unknown }) {
+}
+/** Encodes one SHA-256 digest without depending on a Node runtime. */
+function encodeDigest(value) {
+    let hex = "";
+    for (const byte of new Uint8Array(value)) {
+        hex += byte.toString(16).padStart(2, "0");
+    }
+    return Sha256HashSchema.make(`sha256:${hex}`);
+}
+/** Hashes exact UTF-8 text through the Web Crypto contract. */
+export const hashText = Effect.fn("AksaraContracts.hashText")((value) => Effect.tryPromise({
+    catch: (cause) => new TextHashError({ cause }),
+    try: () => crypto.subtle
+        .digest("SHA-256", new TextEncoder().encode(value))
+        .then(encodeDigest),
+}));

package/dist/ids.d.ts

@@ -0,0 +1,27 @@
+import { Schema } from "effect";
+/** Maximum wire length shared by every published content identity. */
+export declare const CONTENT_KEY_MAX_LENGTH = 512;
+/** Stable content identity shared across locales and immutable releases. */
+export declare const ContentKeySchema: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+export type ContentKey = typeof ContentKeySchema.Type;
+/** Immutable publication generation identity. */
+export declare const ReleaseIdSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+export type ReleaseId = typeof ReleaseIdSchema.Type;
+/** Canonical stored public route without a locale or leading slash. */
+export declare const PublicPathSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+export type PublicPath = typeof PublicPathSchema.Type;
+/** Reviewed Git path used to reproduce one exact authored source revision. */
+export declare const CorpusSourcePathSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+export type CorpusSourcePath = typeof CorpusSourcePathSchema.Type;
+/** Full lowercase Git commit SHA recorded in a release manifest. */
+export declare const GitCommitShaSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+export type GitCommitSha = typeof GitCommitShaSchema.Type;
+/** Canonical SHA-256 value with an explicit algorithm prefix. */
+export declare const Sha256HashSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+export type Sha256Hash = typeof Sha256HashSchema.Type;
+/** Stable identifier selecting one trusted Ed25519 verification key. */
+export declare const SigningKeyIdSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+export type SigningKeyId = typeof SigningKeyIdSchema.Type;
+/** Unpadded base64url encoding of one 64-byte Ed25519 signature. */
+export declare const Ed25519SignatureSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+export type Ed25519Signature = typeof Ed25519SignatureSchema.Type;

package/dist/ids.js

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+const HEX_40_PATTERN = /^[a-f\d]{40}$/;
+const SHA256_PATTERN = /^sha256:[a-f\d]{64}$/;
+const ED25519_SIGNATURE_PATTERN = /^[A-Za-z0-9_-]{85}[AQgw]$/;
+const SIGNING_KEY_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+/** Maximum wire length shared by every published content identity. */
+export const CONTENT_KEY_MAX_LENGTH = 512;
+const CONTENT_KEY_PATTERN = /^[a-z0-9][a-z0-9._:/-]*$/;
+const RELEASE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+const PUBLIC_PATH_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/;
+const CORPUS_SOURCE_PATH_PATTERN = /^packages\/corpus\/[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)+$/;
+/** Checks whether a value is a complete lowercase Git commit SHA. */
+function isGitCommitSha(value) {
+    return HEX_40_PATTERN.test(value);
+}
+/** Checks whether a value uses Aksara's canonical SHA-256 wire format. */
+function isSha256Hash(value) {
+    return SHA256_PATTERN.test(value);
+}
+/** Checks whether a value is a canonical unpadded Ed25519 signature. */
+function isEd25519Signature(value) {
+    return ED25519_SIGNATURE_PATTERN.test(value);
+}
+/** Checks whether a value is a wire-safe signing key identifier. */
+function isSigningKeyId(value) {
+    return SIGNING_KEY_ID_PATTERN.test(value);
+}
+/** Checks whether a value is a bounded canonical public route. */
+function isPublicPath(value) {
+    return value.length <= 2048 && PUBLIC_PATH_PATTERN.test(value);
+}
+/** Checks whether a Git path stays inside the authored corpus workspace. */
+function isCorpusSourcePath(value) {
+    return value.length <= 2048 && CORPUS_SOURCE_PATH_PATTERN.test(value);
+}
+/** Stable content identity shared across locales and immutable releases. */
+export const ContentKeySchema = Schema.String.pipe(Schema.check(Schema.isPattern(CONTENT_KEY_PATTERN)), Schema.check(Schema.isMaxLength(CONTENT_KEY_MAX_LENGTH)), Schema.brand("@NakafaAI/AksaraContentKey"));
+/** Immutable publication generation identity. */
+export const ReleaseIdSchema = Schema.String.pipe(Schema.check(Schema.isPattern(RELEASE_ID_PATTERN)), Schema.brand("@NakafaAI/AksaraReleaseId"));
+/** Canonical stored public route without a locale or leading slash. */
+export const PublicPathSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isPublicPath, {
+    message: "Expected a canonical slashless public path.",
+})), Schema.brand("@NakafaAI/AksaraPublicPath"));
+/** Reviewed Git path used to reproduce one exact authored source revision. */
+export const CorpusSourcePathSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isCorpusSourcePath, {
+    message: "Expected a safe relative source path below packages/corpus.",
+})), Schema.brand("@NakafaAI/AksaraCorpusSourcePath"));
+/** Full lowercase Git commit SHA recorded in a release manifest. */
+export const GitCommitShaSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isGitCommitSha, {
+    message: "Expected a 40-character lowercase Git commit SHA.",
+})), Schema.brand("@NakafaAI/AksaraGitCommitSha"));
+/** Canonical SHA-256 value with an explicit algorithm prefix. */
+export const Sha256HashSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isSha256Hash, {
+    message: "Expected sha256 followed by 64 lowercase hexadecimal characters.",
+})), Schema.brand("@NakafaAI/AksaraSha256Hash"));
+/** Stable identifier selecting one trusted Ed25519 verification key. */
+export const SigningKeyIdSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isSigningKeyId, {
+    message: "Expected a lowercase wire-safe signing key identifier up to 64 characters.",
+})), Schema.brand("@NakafaAI/AksaraSigningKeyId"));
+/** Unpadded base64url encoding of one 64-byte Ed25519 signature. */
+export const Ed25519SignatureSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isEd25519Signature, {
+    message: "Expected a canonical unpadded base64url 64-byte Ed25519 signature.",
+})), Schema.brand("@NakafaAI/AksaraEd25519Signature"));

package/dist/limits.d.ts

@@ -0,0 +1,10 @@
+/** Maximum UTF-8 bytes accepted for one authored MDX source. */
+export declare const MAX_RAW_MDX_BYTES: number;
+/** Maximum UTF-8 bytes accepted for one emitted MDX function body. */
+export declare const MAX_COMPILED_CODE_BYTES: number;
+/** Maximum UTF-8 bytes accepted for one extracted plain-text projection. */
+export declare const MAX_PLAIN_TEXT_BYTES: number;
+/** Maximum UTF-8 bytes for all canonical compiled payload fields. */
+export declare const MAX_CANONICAL_PAYLOAD_BYTES: number;
+/** Maximum UTF-8 bytes for a complete signed artifact wire value. */
+export declare const MAX_SIGNED_ARTIFACT_BYTES: number;

package/dist/limits.js

@@ -0,0 +1,10 @@
+/** Maximum UTF-8 bytes accepted for one authored MDX source. */
+export const MAX_RAW_MDX_BYTES = 128 * 1024;
+/** Maximum UTF-8 bytes accepted for one emitted MDX function body. */
+export const MAX_COMPILED_CODE_BYTES = 256 * 1024;
+/** Maximum UTF-8 bytes accepted for one extracted plain-text projection. */
+export const MAX_PLAIN_TEXT_BYTES = 128 * 1024;
+/** Maximum UTF-8 bytes for all canonical compiled payload fields. */
+export const MAX_CANONICAL_PAYLOAD_BYTES = 448 * 1024;
+/** Maximum UTF-8 bytes for a complete signed artifact wire value. */
+export const MAX_SIGNED_ARTIFACT_BYTES = 480 * 1024;

package/dist/locale.d.ts

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+/** Stable locale codes supported by the current Aksara contract. */
+export declare const AppLocaleCodeSchema: Schema.Literals<readonly ["en", "id", "de"]>;
+export type AppLocaleCode = typeof AppLocaleCodeSchema.Type;
+export declare const ENGLISH_APP_LOCALE_CODE: "en", INDONESIAN_APP_LOCALE_CODE: "id", GERMAN_APP_LOCALE_CODE: "de";
+/** Application locale used for Nakafa-owned interface and explanation copy. */
+export declare const AppLocaleSchema: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+export type AppLocale = typeof AppLocaleSchema.Type;
+/** Narrows one canonical locale code while preserving application identity. */
+export declare function appLocaleLiteral<const Code extends AppLocaleCode>(code: Code): Schema.brand<Schema.Literal<Code>, "@NakafaAI/AksaraAppLocale">;
+/** Constructs one application locale without widening its literal identity. */
+export declare function makeAppLocale<const Code extends AppLocaleCode>(code: Code): Code & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+/** Language delivered by content whose language may differ from the app shell. */
+export declare const DeliveryLanguageSchema: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraDeliveryLanguage">;
+export type DeliveryLanguage = typeof DeliveryLanguageSchema.Type;
+/** Locale identity of one immutable compiled content artifact. */
+export declare const ArtifactLocaleSchema: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+export type ArtifactLocale = typeof ArtifactLocaleSchema.Type;
+/** Canonical locale order used by every active-locale subset. */
+export declare const APP_LOCALE_CODES: readonly ["en", "id", "de"];
+/** Source-controlled application locale codes included by this corpus. */
+export declare const ActiveAppLocaleCodeSchema: Schema.Literals<readonly ["en", "id", "de"]>;
+export type ActiveAppLocaleCode = typeof ActiveAppLocaleCodeSchema.Type;
+/** Source-controlled codes used to index the currently complete corpus. */
+export declare const ACTIVE_APP_LOCALE_CODES: readonly ["en", "id", "de"];
+/** Application locale currently required from every authored scope. */
+export declare const ActiveAppLocaleSchema: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+export type ActiveAppLocale = typeof ActiveAppLocaleSchema.Type;
+/** Returns the plain source-map key for one validated active app locale. */
+export declare function activeAppLocaleCode(appLocale: ActiveAppLocale): "de" | "en" | "id";
+/** Returns the plain source-map key for one validated artifact locale. */
+export declare function artifactLocaleCode(artifactLocale: ArtifactLocale): "de" | "en" | "id";
+/** Nonempty unique active locale subset in canonical contract order. */
+export declare const ActiveAppLocaleListSchema: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+export type ActiveAppLocaleList = typeof ActiveAppLocaleListSchema.Type;
+/** Source-controlled application locales included by the current corpus. */
+export declare const ACTIVE_APP_LOCALES: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];

package/dist/locale.js

@@ -0,0 +1,53 @@
+import { Schema } from "effect";
+/** Stable locale codes supported by the current Aksara contract. */
+export const AppLocaleCodeSchema = Schema.Literals(["en", "id", "de"]);
+export const [ENGLISH_APP_LOCALE_CODE, INDONESIAN_APP_LOCALE_CODE, GERMAN_APP_LOCALE_CODE,] = AppLocaleCodeSchema.literals;
+const APP_LOCALE_BRAND = "@NakafaAI/AksaraAppLocale";
+/** Application locale used for Nakafa-owned interface and explanation copy. */
+export const AppLocaleSchema = AppLocaleCodeSchema.pipe(Schema.brand(APP_LOCALE_BRAND));
+/** Narrows one canonical locale code while preserving application identity. */
+export function appLocaleLiteral(code) {
+    return Schema.Literal(code).pipe(Schema.brand(APP_LOCALE_BRAND));
+}
+/** Constructs one application locale without widening its literal identity. */
+export function makeAppLocale(code) {
+    return appLocaleLiteral(code).make(code);
+}
+/** Language delivered by content whose language may differ from the app shell. */
+export const DeliveryLanguageSchema = AppLocaleCodeSchema.pipe(Schema.brand("@NakafaAI/AksaraDeliveryLanguage"));
+/** Locale identity of one immutable compiled content artifact. */
+export const ArtifactLocaleSchema = AppLocaleCodeSchema.pipe(Schema.brand("@NakafaAI/AksaraArtifactLocale"));
+/** Canonical locale order used by every active-locale subset. */
+export const APP_LOCALE_CODES = AppLocaleCodeSchema.literals;
+/** Source-controlled application locale codes included by this corpus. */
+export const ActiveAppLocaleCodeSchema = AppLocaleCodeSchema;
+/** Source-controlled codes used to index the currently complete corpus. */
+export const ACTIVE_APP_LOCALE_CODES = ActiveAppLocaleCodeSchema.literals;
+/** Application locale currently required from every authored scope. */
+export const ActiveAppLocaleSchema = ActiveAppLocaleCodeSchema.pipe(Schema.brand(APP_LOCALE_BRAND));
+/** Returns the plain source-map key for one validated active app locale. */
+export function activeAppLocaleCode(appLocale) {
+    return Schema.encodeSync(ActiveAppLocaleSchema)(appLocale);
+}
+/** Returns the plain source-map key for one validated artifact locale. */
+export function artifactLocaleCode(artifactLocale) {
+    return Schema.encodeSync(ArtifactLocaleSchema)(artifactLocale);
+}
+/** Checks a nonempty locale subset for uniqueness and canonical order. */
+function hasCanonicalActiveAppLocales(locales) {
+    let previousIndex = -1;
+    for (const locale of locales) {
+        const index = APP_LOCALE_CODES.indexOf(locale);
+        if (index <= previousIndex) {
+            return false;
+        }
+        previousIndex = index;
+    }
+    return true;
+}
+/** Nonempty unique active locale subset in canonical contract order. */
+export const ActiveAppLocaleListSchema = Schema.NonEmptyArray(AppLocaleSchema).pipe(Schema.check(Schema.makeFilter(hasCanonicalActiveAppLocales, {
+    message: "Active app locales must be unique and follow en, id, de order.",
+})));
+/** Source-controlled application locales included by the current corpus. */
+export const ACTIVE_APP_LOCALES = Schema.decodeSync(Schema.NonEmptyArray(ActiveAppLocaleSchema))(ACTIVE_APP_LOCALE_CODES);

package/dist/material/domain.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+/** Stable language-neutral identity for one authored material domain. */
+export declare const MaterialDomainSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialDomain">;
+export type MaterialDomain = typeof MaterialDomainSchema.Type;

package/dist/material/domain.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+import { isLowerKebab } from "#contracts/text/syntax";
+/** Stable language-neutral identity for one authored material domain. */
+export const MaterialDomainSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isLowerKebab, {
+    description: "Lowercase kebab-case material domain key.",
+    identifier: "MaterialDomain",
+    message: "Invalid material domain. Expected lowercase kebab-case.",
+})), Schema.check(Schema.isMaxLength(128)), Schema.brand("@NakafaAI/AksaraMaterialDomain"));