@substrat-run/contracts 0.1.0

package/dist/permission.d.ts

@@ -0,0 +1,257 @@
+import { z } from 'zod';
+export declare const node: z.ZodObject<{
+    tenantId: z.ZodBranded<z.ZodString, "TenantId">;
+    scopeId: z.ZodNullable<z.ZodBranded<z.ZodString, "ScopeId">>;
+}, "strip", z.ZodTypeAny, {
+    tenantId: string & z.BRAND<"TenantId">;
+    scopeId: (string & z.BRAND<"ScopeId">) | null;
+}, {
+    tenantId: string;
+    scopeId: string | null;
+}>;
+export type Node = z.infer<typeof node>;
+export declare const roleKey: z.ZodString;
+export declare const roleDefinition: z.ZodObject<{
+    key: z.ZodString;
+    permissions: z.ZodArray<z.ZodBranded<z.ZodString, "PermissionKey">, "many">;
+    source: z.ZodUnion<[z.ZodBranded<z.ZodString, "ModuleId">, z.ZodLiteral<"vertical">]>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    permissions: (string & z.BRAND<"PermissionKey">)[];
+    source: (string & z.BRAND<"ModuleId">) | "vertical";
+}, {
+    key: string;
+    permissions: string[];
+    source: string;
+}>;
+export type RoleDefinition = z.infer<typeof roleDefinition>;
+export declare const roleAssignment: z.ZodObject<{
+    principalId: z.ZodBranded<z.ZodString, "PrincipalId">;
+    roleKey: z.ZodString;
+    node: z.ZodObject<{
+        tenantId: z.ZodBranded<z.ZodString, "TenantId">;
+        scopeId: z.ZodNullable<z.ZodBranded<z.ZodString, "ScopeId">>;
+    }, "strip", z.ZodTypeAny, {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    }, {
+        tenantId: string;
+        scopeId: string | null;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    principalId: string & z.BRAND<"PrincipalId">;
+    roleKey: string;
+    node: {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    };
+}, {
+    principalId: string;
+    roleKey: string;
+    node: {
+        tenantId: string;
+        scopeId: string | null;
+    };
+}>;
+export type RoleAssignment = z.infer<typeof roleAssignment>;
+export declare const capabilityGrant: z.ZodObject<{
+    principalId: z.ZodBranded<z.ZodString, "PrincipalId">;
+    permission: z.ZodBranded<z.ZodString, "PermissionKey">;
+    node: z.ZodObject<{
+        tenantId: z.ZodBranded<z.ZodString, "TenantId">;
+        scopeId: z.ZodNullable<z.ZodBranded<z.ZodString, "ScopeId">>;
+    }, "strip", z.ZodTypeAny, {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    }, {
+        tenantId: string;
+        scopeId: string | null;
+    }>;
+    entity: z.ZodOptional<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        entityType: string;
+        entityId: string;
+    }, {
+        entityType: string;
+        entityId: string;
+    }>>;
+    expiresAt: z.ZodOptional<z.ZodBranded<z.ZodString, "Instant">>;
+    grantedBy: z.ZodBranded<z.ZodString, "PrincipalId">;
+}, "strip", z.ZodTypeAny, {
+    principalId: string & z.BRAND<"PrincipalId">;
+    node: {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    };
+    permission: string & z.BRAND<"PermissionKey">;
+    grantedBy: string & z.BRAND<"PrincipalId">;
+    entity?: {
+        entityType: string;
+        entityId: string;
+    } | undefined;
+    expiresAt?: (string & z.BRAND<"Instant">) | undefined;
+}, {
+    principalId: string;
+    node: {
+        tenantId: string;
+        scopeId: string | null;
+    };
+    permission: string;
+    grantedBy: string;
+    entity?: {
+        entityType: string;
+        entityId: string;
+    } | undefined;
+    expiresAt?: string | undefined;
+}>;
+export type CapabilityGrant = z.infer<typeof capabilityGrant>;
+export declare const objectRef: z.ZodBranded<z.ZodString, "ObjectRef">;
+export type ObjectRef = z.infer<typeof objectRef>;
+export declare const relationName: z.ZodString;
+export declare const relationTuple: z.ZodObject<{
+    subject: z.ZodBranded<z.ZodString, "ObjectRef">;
+    relation: z.ZodString;
+    object: z.ZodBranded<z.ZodString, "ObjectRef">;
+}, "strip", z.ZodTypeAny, {
+    object: string & z.BRAND<"ObjectRef">;
+    subject: string & z.BRAND<"ObjectRef">;
+    relation: string;
+}, {
+    object: string;
+    subject: string;
+    relation: string;
+}>;
+export type RelationTuple = z.infer<typeof relationTuple>;
+export declare const decision: z.ZodDiscriminatedUnion<"allowed", [z.ZodObject<{
+    allowed: z.ZodLiteral<true>;
+    proof: z.ZodArray<z.ZodObject<{
+        subject: z.ZodBranded<z.ZodString, "ObjectRef">;
+        relation: z.ZodString;
+        object: z.ZodBranded<z.ZodString, "ObjectRef">;
+    }, "strip", z.ZodTypeAny, {
+        object: string & z.BRAND<"ObjectRef">;
+        subject: string & z.BRAND<"ObjectRef">;
+        relation: string;
+    }, {
+        object: string;
+        subject: string;
+        relation: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    allowed: true;
+    proof: {
+        object: string & z.BRAND<"ObjectRef">;
+        subject: string & z.BRAND<"ObjectRef">;
+        relation: string;
+    }[];
+}, {
+    allowed: true;
+    proof: {
+        object: string;
+        subject: string;
+        relation: string;
+    }[];
+}>, z.ZodObject<{
+    allowed: z.ZodLiteral<false>;
+    checked: z.ZodBranded<z.ZodString, "PermissionKey">;
+    node: z.ZodObject<{
+        tenantId: z.ZodBranded<z.ZodString, "TenantId">;
+        scopeId: z.ZodNullable<z.ZodBranded<z.ZodString, "ScopeId">>;
+    }, "strip", z.ZodTypeAny, {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    }, {
+        tenantId: string;
+        scopeId: string | null;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    node: {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    };
+    allowed: false;
+    checked: string & z.BRAND<"PermissionKey">;
+}, {
+    node: {
+        tenantId: string;
+        scopeId: string | null;
+    };
+    allowed: false;
+    checked: string;
+}>]>;
+export type Decision = z.infer<typeof decision>;
+export declare const effectivePermissions: z.ZodObject<{
+    principalId: z.ZodBranded<z.ZodString, "PrincipalId">;
+    node: z.ZodObject<{
+        tenantId: z.ZodBranded<z.ZodString, "TenantId">;
+        scopeId: z.ZodNullable<z.ZodBranded<z.ZodString, "ScopeId">>;
+    }, "strip", z.ZodTypeAny, {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    }, {
+        tenantId: string;
+        scopeId: string | null;
+    }>;
+    permissions: z.ZodArray<z.ZodObject<{
+        permission: z.ZodBranded<z.ZodString, "PermissionKey">;
+        proof: z.ZodArray<z.ZodObject<{
+            subject: z.ZodBranded<z.ZodString, "ObjectRef">;
+            relation: z.ZodString;
+            object: z.ZodBranded<z.ZodString, "ObjectRef">;
+        }, "strip", z.ZodTypeAny, {
+            object: string & z.BRAND<"ObjectRef">;
+            subject: string & z.BRAND<"ObjectRef">;
+            relation: string;
+        }, {
+            object: string;
+            subject: string;
+            relation: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        permission: string & z.BRAND<"PermissionKey">;
+        proof: {
+            object: string & z.BRAND<"ObjectRef">;
+            subject: string & z.BRAND<"ObjectRef">;
+            relation: string;
+        }[];
+    }, {
+        permission: string;
+        proof: {
+            object: string;
+            subject: string;
+            relation: string;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    permissions: {
+        permission: string & z.BRAND<"PermissionKey">;
+        proof: {
+            object: string & z.BRAND<"ObjectRef">;
+            subject: string & z.BRAND<"ObjectRef">;
+            relation: string;
+        }[];
+    }[];
+    principalId: string & z.BRAND<"PrincipalId">;
+    node: {
+        tenantId: string & z.BRAND<"TenantId">;
+        scopeId: (string & z.BRAND<"ScopeId">) | null;
+    };
+}, {
+    permissions: {
+        permission: string;
+        proof: {
+            object: string;
+            subject: string;
+            relation: string;
+        }[];
+    }[];
+    principalId: string;
+    node: {
+        tenantId: string;
+        scopeId: string | null;
+    };
+}>;
+export type EffectivePermissions = z.infer<typeof effectivePermissions>;
+//# sourceMappingURL=permission.d.ts.map

package/dist/permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../src/permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,IAAI;;;;;;;;;EAGf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,OAAO,aAAwD,CAAC;AAE7E,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAM5D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAW9D,eAAO,MAAM,SAAS,wCAGC,CAAC;AACxB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAGlD,eAAO,MAAM,YAAY,aAAqC,CAAC;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAQ1D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/permission.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { instant, moduleId, permissionKey, principalId, scopeId, tenantId } from './ids.js';
+import { entityRef } from './events.js';
+// ============================================================================
+// Authored surface — what humans and agents write (design doc §4.1).
+// ============================================================================
+// A node in the assignable tree: tenant root (scopeId null) or a scope.
+export const node = z.object({
+    tenantId,
+    scopeId: scopeId.nullable(),
+});
+export const roleKey = z.string().regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/);
+export const roleDefinition = z.object({
+    key: roleKey,
+    permissions: z.array(permissionKey).min(1),
+    source: z.union([moduleId, z.literal('vertical')]),
+});
+export const roleAssignment = z.object({
+    principalId,
+    roleKey,
+    node,
+});
+// Narrow, direct, time-boxable; also the cross-tenant mechanism (§5.4).
+// `entity` narrows the grant to one entity and its declared descendants —
+// how portal customers see only their own facilities/orders inside a shared
+// scope (design doc §4.1, K-12). Always audited.
+export const capabilityGrant = z.object({
+    principalId,
+    permission: permissionKey,
+    node,
+    entity: entityRef.optional(),
+    expiresAt: instant.optional(),
+    grantedBy: principalId,
+});
+// ============================================================================
+// Evaluation representation — relationship tuples (design doc §4.2, plan D-23).
+// Internal to the checker; verticals never author these. The fixed derivation
+// algebra (role expansion, tree inheritance, declared entity parent edges,
+// membership) lives in the evaluator, not in configurable rewrites.
+// ============================================================================
+// 'principal:<ulid>' | 'org:<ulid>' | 'tenant:<ulid>' | 'scope:<ulid>' |
+// '<entityType>:<entityId>' — namespace:id
+export const objectRef = z
+    .string()
+    .regex(/^[a-z0-9_-]+:[^\s]+$/)
+    .brand();
+// 'member' | 'parent' | 'role:staff' | 'granted:workorder:read' …
+export const relationName = z.string().regex(/^[a-z0-9_:-]+$/);
+export const relationTuple = z.object({
+    subject: objectRef,
+    relation: relationName,
+    object: objectRef,
+});
+// ============================================================================
+// Decisions — an allow ALWAYS carries its proof: the tuple chain that granted
+// access. Powers explain(), "view as user" (§7.8), and the human-readable
+// permission diff. An unexplained allow is unrepresentable.
+// ============================================================================
+export const decision = z.discriminatedUnion('allowed', [
+    z.object({
+        allowed: z.literal(true),
+        proof: z.array(relationTuple).min(1),
+    }),
+    z.object({
+        allowed: z.literal(false),
+        checked: permissionKey,
+        node,
+    }),
+]);
+export const effectivePermissions = z.object({
+    principalId,
+    node,
+    permissions: z.array(z.object({
+        permission: permissionKey,
+        proof: z.array(relationTuple).min(1),
+    })),
+});
+//# sourceMappingURL=permission.js.map

package/dist/permission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.js","sourceRoot":"","sources":["../src/permission.ts"],"names":[],"mappings":"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"}

package/dist/tenancy.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+export declare const tenantStatus: z.ZodEnum<["active", "suspended", "deleting"]>;
+export type TenantStatus = z.infer<typeof tenantStatus>;
+export declare const tenant: z.ZodObject<{
+    id: z.ZodBranded<z.ZodString, "TenantId">;
+    slug: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodEnum<["active", "suspended", "deleting"]>;
+    createdAt: z.ZodBranded<z.ZodString, "Instant">;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "suspended" | "deleting";
+    id: string & z.BRAND<"TenantId">;
+    slug: string;
+    name: string;
+    createdAt: string & z.BRAND<"Instant">;
+}, {
+    status: "active" | "suspended" | "deleting";
+    id: string;
+    slug: string;
+    name: string;
+    createdAt: string;
+}>;
+export type Tenant = z.infer<typeof tenant>;
+export declare const scopeStatus: z.ZodEnum<["provisioning", "active", "suspended", "archiving", "archived"]>;
+export type ScopeStatus = z.infer<typeof scopeStatus>;
+export declare const storageShape: z.ZodEnum<["A", "B"]>;
+export type StorageShape = z.infer<typeof storageShape>;
+export declare const jurisdiction: z.ZodNullable<z.ZodEnum<["eu"]>>;
+export type Jurisdiction = z.infer<typeof jurisdiction>;
+export declare const scope: z.ZodObject<{
+    id: z.ZodBranded<z.ZodString, "ScopeId">;
+    tenantId: z.ZodBranded<z.ZodString, "TenantId">;
+    parentScopeId: z.ZodNullable<z.ZodBranded<z.ZodString, "ScopeId">>;
+    slug: z.ZodString;
+    kind: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodEnum<["provisioning", "active", "suspended", "archiving", "archived"]>;
+    storageShape: z.ZodEnum<["A", "B"]>;
+    jurisdiction: z.ZodNullable<z.ZodEnum<["eu"]>>;
+    schemaVersion: z.ZodString;
+    createdAt: z.ZodBranded<z.ZodString, "Instant">;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "suspended" | "provisioning" | "archiving" | "archived";
+    schemaVersion: string;
+    id: string & z.BRAND<"ScopeId">;
+    tenantId: string & z.BRAND<"TenantId">;
+    slug: string;
+    name: string;
+    createdAt: string & z.BRAND<"Instant">;
+    parentScopeId: (string & z.BRAND<"ScopeId">) | null;
+    kind: string;
+    storageShape: "A" | "B";
+    jurisdiction: "eu" | null;
+}, {
+    status: "active" | "suspended" | "provisioning" | "archiving" | "archived";
+    schemaVersion: string;
+    id: string;
+    tenantId: string;
+    slug: string;
+    name: string;
+    createdAt: string;
+    parentScopeId: string | null;
+    kind: string;
+    storageShape: "A" | "B";
+    jurisdiction: "eu" | null;
+}>;
+export type Scope = z.infer<typeof scope>;
+//# sourceMappingURL=tenancy.d.ts.map

package/dist/tenancy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenancy.d.ts","sourceRoot":"","sources":["../src/tenancy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,YAAY,gDAA8C,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;EAMjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE5C,eAAO,MAAM,WAAW,6EAMtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAGtD,eAAO,MAAM,YAAY,uBAAqB,CAAC;AAC/C,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAGxD,eAAO,MAAM,YAAY,kCAA4B,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYhB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC"}

package/dist/tenancy.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { instant, scopeId, slug, tenantId } from './ids.js';
+export const tenantStatus = z.enum(['active', 'suspended', 'deleting']);
+export const tenant = z.object({
+    id: tenantId,
+    slug,
+    name: z.string().min(1),
+    status: tenantStatus,
+    createdAt: instant,
+});
+export const scopeStatus = z.enum([
+    'provisioning',
+    'active',
+    'suspended',
+    'archiving',
+    'archived',
+]);
+// §5.2 of the design doc: A = DO-embedded SQLite is primary; B = DO control plane + D1
+export const storageShape = z.enum(['A', 'B']);
+// Fixed at provisioning; a DO can never relocate (design K-7)
+export const jurisdiction = z.enum(['eu']).nullable();
+export const scope = z.object({
+    id: scopeId, // globally unique; APIs still take (tenantId, scopeId) and cross-check (K-3)
+    tenantId,
+    parentScopeId: scopeId.nullable(), // v1: always null; column ships so trees are additive (K-1)
+    slug, // unique within tenant
+    kind: z.string().min(1), // vertical vocabulary ('brf', 'filial'); kernel never branches on it
+    name: z.string().min(1),
+    status: scopeStatus,
+    storageShape,
+    jurisdiction,
+    schemaVersion: z.string(),
+    createdAt: instant,
+});
+//# sourceMappingURL=tenancy.js.map

package/dist/tenancy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenancy.js","sourceRoot":"","sources":["../src/tenancy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE5D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;AAGxE,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7B,EAAE,EAAE,QAAQ;IACZ,IAAI;IACJ,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,OAAO;CACnB,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC;IAChC,cAAc;IACd,QAAQ;IACR,WAAW;IACX,WAAW;IACX,UAAU;CACX,CAAC,CAAC;AAGH,uFAAuF;AACvF,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAG/C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;AAGtD,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,EAAE,EAAE,OAAO,EAAE,6EAA6E;IAC1F,QAAQ;IACR,aAAa,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,4DAA4D;IAC/F,IAAI,EAAE,uBAAuB;IAC7B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,qEAAqE;IAC9F,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,MAAM,EAAE,WAAW;IACnB,YAAY;IACZ,YAAY;IACZ,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,SAAS,EAAE,OAAO;CACnB,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@substrat-run/contracts",
+  "version": "0.1.0",
+  "description": "Substrat kernel contract schemas — Zod is the source of truth (master plan D-22); OAS/JSON Schema are emitted artifacts",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/substrat-run/substrat.git",
+    "directory": "packages/contracts"
+  },
+  "homepage": "https://github.com/substrat-run/substrat",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}