@astrale-os/kernel-dsl 1.0.0-beta.16 → 1.0.0-beta.17

package/dist/v1/schema/validation/domain.structure.js

@@ -277,7 +277,7 @@ const policyCheckObjectSchema = discriminatedUnion('kind', [
     }),
     refObjectSchema,
 ]).register(documentJsonSchema, { id: 'policy-check-object' });
-/** A Node Class rule checks the observed Node or one exact member: it has no input. */
+/** A Class rule checks the observed or written instance or one exact member: it has no input. */
 const classRuleObjectSchema = discriminatedUnion('kind', [
     selfObjectSchema,
     refObjectSchema,
@@ -294,6 +294,8 @@ function policyChecksSchema(objectSchema, id) {
 }
 const policyCheckExpressionSchema = policyChecksSchema(policyCheckObjectSchema, 'policy-check-expr');
 const classRuleChecksSchema = policyChecksSchema(classRuleObjectSchema, 'class-rule-check-expr');
+/** A Node create rule has no Node to check yet: its objects are exact members only. */
+const createRuleChecksSchema = policyChecksSchema(refObjectSchema, 'create-rule-check-expr');
 const callableOutputSchema = discriminatedUnion('mode', [
     strictObject({
         mode: literal('value'),
@@ -353,17 +355,27 @@ const methodDeclarationSchema = strictObject({
 const methodRecordSchema = record(memberNameSchema, methodDeclarationSchema).register(documentJsonSchema, {
     id: 'method-record',
 });
-const classPolicySchema = union([literal(false), policyRefSchema]).register(documentJsonSchema, {
-    id: 'class-policy',
-});
-const nodeClassPolicySchema = union([classPolicySchema, classRuleChecksSchema]).register(documentJsonSchema, { id: 'node-class-policy' });
+// Each slot spells one constant: the other one is what its absence already means.
+const observationPolicySchema = union([
+    literal(false),
+    policyRefSchema,
+    classRuleChecksSchema,
+]).register(documentJsonSchema, { id: 'observation-policy' });
+const writePolicySchema = union([literal(true), policyRefSchema, classRuleChecksSchema]).register(documentJsonSchema, { id: 'write-policy' });
+const createPolicySchema = union([literal(true), createRuleChecksSchema]).register(documentJsonSchema, { id: 'create-policy' });
 const nodeClassPoliciesSchema = strictObject({
-    read: nodeClassPolicySchema.optional(),
-    traverse: nodeClassPolicySchema.optional(),
+    read: observationPolicySchema.optional(),
+    traverse: observationPolicySchema.optional(),
+    create: createPolicySchema.optional(),
+    update: writePolicySchema.optional(),
+    delete: writePolicySchema.optional(),
 });
 const edgeClassPoliciesSchema = strictObject({
-    read: classPolicySchema.optional(),
-    traverse: classPolicySchema.optional(),
+    read: observationPolicySchema.optional(),
+    traverse: observationPolicySchema.optional(),
+    create: writePolicySchema.optional(),
+    update: writePolicySchema.optional(),
+    delete: writePolicySchema.optional(),
 });
 // The default `'internal'` is the absence of the field: one spelling per meaning, one revision.
 const inheritanceSchema = enumeration(['open', 'final']);

package/dist/v1/schema/validation/json.json-schema.d.ts

@@ -1,5 +1,22 @@
 import type { core as zodCore } from 'zod';
-type JsonSchema = zodCore.JSONSchema.JSONSchema;
+import type { DiagnosticCode as ValueDiagnosticCode } from '../../language/validation/diagnostic.js';
+import type { SchemaDiagnosticCode } from '../diagnostic.js';
+/** A JSON Schema of the published document, or a part of one. */
+export type JsonSchema = zodCore.JSONSchema.JSONSchema;
+/**
+ * A check JSON Schema cannot state, which the published document names: the code the Kernel
+ * reports, with its value code for a check on value schemas, and the rule in one plain sentence.
+ */
+export interface NamedRuleEntry {
+    readonly code: SchemaDiagnosticCode;
+    readonly valueCode?: ValueDiagnosticCode;
+    readonly statement: string;
+}
+/**
+ * `schema` with the `x-astrale-rule` marker naming the checks of `Rule` it leaves to the Kernel.
+ * `Rule` is given at each call, so that a name outside it does not compile.
+ */
+export declare function named<Rule extends string = never>(schema: JsonSchema, ...rules: [NoInfer<Rule>, ...NoInfer<Rule>[]]): JsonSchema;
 /**
  * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
  * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
@@ -21,4 +38,3 @@ export declare function jsonValueJsonSchema(): {
     readonly root: JsonSchema;
     readonly definitions: Readonly<Record<string, JsonSchema>>;
 };
-export {};

package/dist/v1/schema/validation/json.json-schema.js

@@ -1,4 +1,11 @@
 import { RULES } from '../rule.js';
+/**
+ * `schema` with the `x-astrale-rule` marker naming the checks of `Rule` it leaves to the Kernel.
+ * `Rule` is given at each call, so that a name outside it does not compile.
+ */
+export function named(schema, ...rules) {
+    return { ...schema, 'x-astrale-rule': rules };
+}
 /**
  * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
  * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
@@ -18,17 +25,20 @@ export function jsonValueJsonSchema() {
     return {
         root: { $ref: VALUE },
         definitions: {
-            'portable-json': {
+            'portable-json': named({
                 anyOf: [
                     { type: 'null' },
                     { type: 'boolean' },
                     { type: 'number' },
                     { $ref: TEXT },
                     { type: 'array', items: { $ref: VALUE } },
-                    { type: 'object', propertyNames: { $ref: TEXT }, additionalProperties: { $ref: VALUE } },
+                    {
+                        type: 'object',
+                        propertyNames: { $ref: TEXT },
+                        additionalProperties: { $ref: VALUE },
+                    },
                 ],
-                'x-astrale-rule': 'portable-json',
-            },
+            }, 'portable-json'),
             // The pattern is the character itself, which every regular-expression dialect reads.
             'portable-string': { type: 'string', not: { pattern: '\u0000' } },
         },

package/dist/v1/schema/validation/policy/budgets.d.ts

@@ -13,7 +13,7 @@ export interface PolicyMeasures {
     readonly unmeasured: readonly string[];
     /**
      * Each check tree by the JSON Pointer of its position: the Policy of a Function or a Method, or
-     * the read or traverse rule of a Node Class.
+     * the rule of a Class slot.
      */
     readonly checks: Readonly<Record<string, CheckMeasure>>;
 }

package/dist/v1/schema/validation/policy/budgets.js

@@ -1,9 +1,9 @@
+import { deepFreeze } from '../../../language/freeze.js';
 import { limits } from '../../../language/limits.js';
 import { exceededLimits, measureChecks, policyMeasurer, } from '../../../language/policy/analysis/budgets.js';
-import { isClassRuleChecks } from '../../../language/policy/model/policy.js';
+import { CLASS_OPERATIONS, isClassRuleChecks } from '../../../language/policy/model/policy.js';
 import { normalizePolicyChecks, normalizePolicyExpression, } from '../../../language/policy/normalization/normalize.js';
 import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
-import { deepFreeze } from '../../canonical/freeze.js';
 import { structureDomainSchema } from '../domain.route.js';
 import { SITE } from './uses.js';
 /**
@@ -55,7 +55,7 @@ export function validateCheckBudget(context, pointer, measure) {
     if (exceededLimits(measure).length === 0)
         return;
     const { checkDepth, checkBranches, checkLeaves } = limits.policy;
-    // A callable holds its checks at `policy`; a Node Class rule at `policies/{operation}`.
+    // A callable holds its checks at `policy`; a Class rule at `policies/{operation}`.
     const site = SITE[pointer.endsWith('/policy') ? 'callable' : 'class'];
     context.add('PL_BUDGET', pointer, `${site.checks} require depth <= ${checkDepth}, branches <= ${checkBranches}, and leaves <= ${checkLeaves}; got ${measure.checkDepth}, ${measure.checkBranches}, ${measure.checkLeaves}.`);
 }
@@ -76,7 +76,7 @@ function normalizedPolicies(schema) {
 function* checkTrees(schema) {
     for (const [name, declaration] of Object.entries(schema.classes)) {
         const owner = `/classes/${escapePointerToken(name)}`;
-        for (const operation of ['read', 'traverse']) {
+        for (const operation of CLASS_OPERATIONS) {
             const rule = declaration.policies[operation];
             if (typeof rule === 'object' && isClassRuleChecks(rule)) {
                 yield [`${owner}/policies/${operation}`, rule];

package/dist/v1/schema/validation/policy/uses.d.ts

@@ -1,4 +1,5 @@
 import type { CallableDefinition } from '../../../language/callable/model/callable.js';
+import type { EdgeContract } from '../../../language/class/model/edge.js';
 import type { PolicyTyping } from '../../../language/policy/analysis/typing.js';
 import type { PolicyCheckExpression } from '../../../language/policy/model/policy.js';
 import type { JsonSchema } from '../../../language/value/model/schema.js';
@@ -10,6 +11,13 @@ interface CheckContext {
     readonly input: JsonSchema;
     /** The Node Class that receives the call, which the checks name `self`; none, and none is named. */
     readonly receiver?: ClassRef;
+    /** In an Edge Class rule, the Edge `self` names, in place of a receiver. */
+    readonly edge?: EdgeUse;
+}
+/** One Edge Class, whose declaration fixes the concrete Node Classes of its endpoints. */
+interface EdgeUse {
+    readonly ref: ClassRef;
+    readonly declaration: EdgeContract;
 }
 /** How a refusal names the checks of each site and the contract of their objects. */
 export declare const SITE: {
@@ -22,8 +30,8 @@ export declare const SITE: {
         readonly objects: 'the Class rule object contract';
     };
 };
-export declare function validateReadUses(context: PolicyValidationContext, typing: PolicyTyping): void;
-export declare function validateTraverseUses(context: PolicyValidationContext, typing: PolicyTyping): void;
+/** Type every Class slot: its Policy against the instance it decides, or its Policy checks. */
+export declare function validateClassUses(context: PolicyValidationContext, typing: PolicyTyping): void;
 export declare function validateCallableUses(context: PolicyValidationContext, typing: PolicyTyping): void;
 /**
  * Validate the Policy of one callable contract written at `pointer`, wherever it is declared:

package/dist/v1/schema/validation/policy/uses.js

@@ -2,7 +2,7 @@ import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { isBinaryInput } from '../../../language/callable/model/callable.js';
 import { neverAdmittedClasses, } from '../../../language/policy/analysis/checks.js';
-import { checksNameTheCaller, isClassRuleChecks } from '../../../language/policy/model/policy.js';
+import { CLASS_OPERATIONS, checksNameTheCaller, isClassRuleChecks, } from '../../../language/policy/model/policy.js';
 import { normalizePolicyChecks } from '../../../language/policy/normalization/normalize.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
 import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
@@ -15,11 +15,10 @@ export const SITE = {
     callable: { checks: 'Callable checks', objects: 'the callable object contract' },
     class: { checks: 'Class rule checks', objects: 'the Class rule object contract' },
 };
-export function validateReadUses(context, typing) {
-    validateClassPolicyUses(context, typing, 'read');
-}
-export function validateTraverseUses(context, typing) {
-    validateClassPolicyUses(context, typing, 'traverse');
+/** Type every Class slot: its Policy against the instance it decides, or its Policy checks. */
+export function validateClassUses(context, typing) {
+    for (const operation of CLASS_OPERATIONS)
+        validateClassPolicyUses(context, typing, operation);
 }
 function validateClassPolicyUses(context, typing, operation) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
@@ -27,23 +26,23 @@ function validateClassPolicyUses(context, typing, operation) {
         if (typeof ref !== 'object')
             continue;
         const pointer = `/classes/${escapePointerToken(name)}/policies/${operation}`;
+        const self = { origin: context.environment.candidate.origin, kind: 'class', name };
         if (isClassRuleChecks(ref)) {
-            // Structure admits Policy checks only on a Node Class: `self` is the observed exact Class.
+            // Structure admits `self` everywhere but in a Node create rule: there is no Node yet.
             validateChecks(context, typing, ref, {
                 site: 'class',
                 pointer,
                 input: {},
-                receiver: { origin: context.environment.candidate.origin, kind: 'class', name },
+                ...(declaration.kind === 'node'
+                    ? { receiver: self }
+                    : { edge: { ref: self, declaration } }),
             });
             continue;
         }
         if (!context.resolvePolicy(ref, pointer))
             continue;
         if (declaration.kind === 'node') {
-            const object = {
-                kind: 'exact',
-                ref: { origin: context.environment.candidate.origin, kind: 'class', name },
-            };
+            const object = { kind: 'exact', ref: self };
             if (typing.policyAccepts(ref.name, object))
                 continue;
             context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of ${operation} Node Class ${name}.`, formatDefinitionRef(ref));
@@ -98,7 +97,11 @@ function visitChecks(validation, typing, expression, context, pointer, leaves) {
     if ('sameNode' in expression) {
         for (const [side, object] of Object.entries(expression.sameNode)) {
             const objectPointer = `${pointer}/sameNode/${side}`;
-            if (object.kind === 'self')
+            if (object.kind === 'self' && context.edge !== undefined) {
+                // `self` is an Edge there, and sameNode compares Nodes.
+                validation.add('PL_USE', objectPointer, 'sameNode compares Nodes: self is an Edge here.');
+            }
+            else if (object.kind === 'self')
                 selfContracts(validation, context, objectPointer);
             else if (object.kind === 'input')
                 inputContracts(validation, context, object.field, objectPointer);
@@ -110,6 +113,16 @@ function visitChecks(validation, typing, expression, context, pointer, leaves) {
     if ('check' in expression) {
         if (!validation.resolvePolicy(expression.check, `${pointer}/check`))
             return;
+        if (expression.object.kind === 'self' && context.edge !== undefined) {
+            // An Edge is checked as an Edge Class Policy is: over every concrete endpoint pair.
+            if (!typing.policyAcceptsEdgeClass(expression.check.name, context.edge.declaration)) {
+                validation.add('PL_USE', pointer, `${formatDefinitionRef(expression.check)} is not valid for every concrete source/target pair of Edge Class ${context.edge.ref.name}.`, formatDefinitionRef(expression.check));
+                return;
+            }
+            const edge = formatDefinitionRef(context.edge.ref);
+            leaves.set(expression, { accepted: [edge], admitted: new Set([edge]) });
+            return;
+        }
         const objectPointer = `${pointer}/object`;
         const contracts = expression.object.kind === 'self'
             ? selfContracts(validation, context, objectPointer)

package/dist/v1/schema/validation/policy/validate.js

@@ -3,7 +3,7 @@ import { validatePolicyBudgets } from './budgets.js';
 import { PolicyValidationContext } from './context.js';
 import { validatePolicyReferences } from './references.js';
 import { validatePolicyTyping } from './typing.js';
-import { validateCallableUses, validateReadUses, validateTraverseUses } from './uses.js';
+import { validateCallableUses, validateClassUses } from './uses.js';
 /**
  * Validates the closed V1 Policy language after structural parsing.
  *
@@ -17,8 +17,7 @@ export function validatePolicies(environment, analysis) {
     validatePolicyBudgets(context);
     const typing = new PolicyTyping(context);
     validatePolicyTyping(context, typing);
-    validateReadUses(context, typing);
-    validateTraverseUses(context, typing);
+    validateClassUses(context, typing);
     validateCallableUses(context, typing);
     return Object.freeze(context.diagnostics);
 }

package/dist/v1/schema/validation/value.json-schema.d.ts

@@ -1,5 +1,4 @@
-import type { core as zodCore } from 'zod';
-type JsonSchema = zodCore.JSONSchema.JSONSchema;
+import { type JsonSchema } from './json.json-schema.js';
 /**
  * The checks on value schemas JSON Schema cannot state, which the published document names with
  * the positions it constrains. The Kernel reports each as `DV_VALUE_SCHEMA`, with its value code.
@@ -18,12 +17,12 @@ export declare const valueSchemaRules: {
     readonly 'value-recursion': {
         readonly code: 'DV_VALUE_SCHEMA';
         readonly valueCode: 'VS_RECURSION_PRODUCTIVE';
-        readonly statement: 'Every reference cycle of a value schema crosses a keyword that steps into the value: to a member, a member name or an item.';
+        readonly statement: string;
     };
     readonly 'value-reference-form': {
         readonly code: 'DV_VALUE_SCHEMA';
         readonly valueCode: 'VS_REFERENCE_FORM';
-        readonly statement: 'A $ref is a JSON Pointer fragment into its own value schema, or the id of the graph NodePath schema beside x-astrale-path.';
+        readonly statement: string;
     };
     readonly 'value-reference-resolution': {
         readonly code: 'DV_VALUE_SCHEMA';
@@ -33,7 +32,7 @@ export declare const valueSchemaRules: {
     readonly 'value-regexp': {
         readonly code: 'DV_VALUE_SCHEMA';
         readonly valueCode: 'VS_REGEX_PORTABLE';
-        readonly statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.';
+        readonly statement: string;
     };
 };
 export type ValueSchemaRule = keyof typeof valueSchemaRules;
@@ -48,4 +47,3 @@ export declare function valueSchemaJsonSchema(): {
     readonly definitions: Readonly<Record<string, JsonSchema>>;
     readonly nodeProperty: JsonSchema;
 };
-export {};

package/dist/v1/schema/validation/value.json-schema.js

@@ -1,5 +1,7 @@
+import { VALUE_RULES } from '../../language/validation/rule.js';
 import { VALUE_SCHEMA_DIALECT } from '../../language/value/model/schema.js';
 import { FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS, } from '../../language/value/profile/vocabulary.js';
+import { named } from './json.json-schema.js';
 /**
  * The checks on value schemas JSON Schema cannot state, which the published document names with
  * the positions it constrains. The Kernel reports each as `DV_VALUE_SCHEMA`, with its value code.
@@ -19,12 +21,12 @@ export const valueSchemaRules = {
     'value-recursion': {
         code: 'DV_VALUE_SCHEMA',
         valueCode: 'VS_RECURSION_PRODUCTIVE',
-        statement: 'Every reference cycle of a value schema crosses a keyword that steps into the value: to a member, a member name or an item.',
+        statement: VALUE_RULES.VS_RECURSION_PRODUCTIVE.statement,
     },
     'value-reference-form': {
         code: 'DV_VALUE_SCHEMA',
         valueCode: 'VS_REFERENCE_FORM',
-        statement: 'A $ref is a JSON Pointer fragment into its own value schema, or the id of the graph NodePath schema beside x-astrale-path.',
+        statement: VALUE_RULES.VS_REFERENCE_FORM.statement,
     },
     'value-reference-resolution': {
         code: 'DV_VALUE_SCHEMA',
@@ -34,7 +36,7 @@ export const valueSchemaRules = {
     'value-regexp': {
         code: 'DV_VALUE_SCHEMA',
         valueCode: 'VS_REGEX_PORTABLE',
-        statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.',
+        statement: VALUE_RULES.VS_REGEX_PORTABLE.statement,
     },
 };
 const KIND = 'x-astrale-value-kind';
@@ -55,10 +57,7 @@ export function valueSchemaJsonSchema() {
             objectOrBoolean({
                 properties: {
                     $schema: { const: VALUE_SCHEMA_DIALECT },
-                    [KIND]: {
-                        enum: ['instant', 'blob'],
-                        'x-astrale-rule': 'value-blob',
-                    },
+                    [KIND]: named({ enum: ['instant', 'blob'] }, 'value-blob'),
                 },
             }),
         ],
@@ -70,31 +69,25 @@ export function valueSchemaJsonSchema() {
                 },
                 properties: {
                     $id: false,
-                    $ref: {
-                        type: 'string',
-                        'x-astrale-rule': [
-                            'value-recursion',
-                            'value-reference-form',
-                            'value-reference-resolution',
-                        ],
-                    },
+                    $ref: named({ type: 'string' }, 'value-recursion', 'value-reference-form', 'value-reference-resolution'),
                     enum: { type: 'array', uniqueItems: true },
-                    fullMatch: { type: 'string', 'x-astrale-rule': 'value-regexp' },
-                    pattern: { type: 'string', 'x-astrale-rule': 'value-regexp' },
-                    'x-astrale-path': { $ref: PATH, 'x-astrale-rule': 'value-path' },
+                    fullMatch: named({ type: 'string' }, 'value-regexp'),
+                    pattern: named({ type: 'string' }, 'value-regexp'),
+                    'x-astrale-path': named({ $ref: PATH }, 'value-path'),
                     ...Object.fromEntries(SUBSCHEMA_KEYWORDS.single.map((keyword) => [keyword, { $ref: SUBSCHEMA }])),
                     ...Object.fromEntries(SUBSCHEMA_KEYWORDS.array.map((keyword) => [
                         keyword,
                         { type: 'array', items: { $ref: SUBSCHEMA } },
                     ])),
-                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.map.map((keyword) => [
-                        keyword,
-                        {
+                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.map.map((keyword) => {
+                        const members = {
                             type: 'object',
                             additionalProperties: { $ref: SUBSCHEMA },
-                            ...(keyword === 'patternProperties' ? { 'x-astrale-rule': 'value-regexp' } : {}),
-                        },
-                    ])),
+                        };
+                        if (keyword !== 'patternProperties')
+                            return [keyword, members];
+                        return [keyword, named(members, 'value-regexp')];
+                    })),
                 },
                 // An instant is a string.
                 if: { required: [KIND], properties: { [KIND]: { const: 'instant' } } },
@@ -111,7 +104,7 @@ export function valueSchemaJsonSchema() {
                         type: 'array',
                         minItems: 1,
                         uniqueItems: true,
-                        items: { $ref: '#/$defs/class-ref', 'x-astrale-rule': 'value-reference-resolution' },
+                        items: named({ $ref: '#/$defs/class-ref' }, 'value-reference-resolution'),
                     },
                 },
                 required: ['target', 'cardinality', 'accepts'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.16",
+  "version": "1.0.0-beta.17",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {

package/dist/v1/schema/canonical/domain.d.ts

@@ -1,3 +0,0 @@
-import type { DomainSchemaIR } from '../model/schema.js';
-/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
-export declare function canonicalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;

package/dist/v1/schema/canonical/domain.digest.d.ts

@@ -1,3 +0,0 @@
-import type { Revision } from '../../addressing/index.js';
-/** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
-export declare function digestDomainSchemaBytes(bytes: Uint8Array): Revision;

package/dist/v1/schema/canonical/domain.digest.js

@@ -1,5 +0,0 @@
-import { digestRevisionBytes } from '../../addressing/revision.js';
-/** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
-export function digestDomainSchemaBytes(bytes) {
-    return digestRevisionBytes(bytes);
-}

package/dist/v1/schema/canonical/domain.js

@@ -1,5 +0,0 @@
-import { normalizeDomainSchema } from '../normalization/domain.js';
-/** Produce the deterministic semantic document consumed by canonical JSON serialization. */
-export function canonicalizeDomainSchema(schema) {
-    return normalizeDomainSchema(schema);
-}

package/dist/v1/schema/canonical/freeze.d.ts

@@ -1 +0,0 @@
-export declare function deepFreeze<T>(value: T): Readonly<T>;