@astrale-os/kernel-dsl 0.2.0-beta.6 → 0.2.0-beta.8

package/dist/v1/domain/create.js

@@ -6,7 +6,7 @@ const admittedDomains = new WeakSet();
 export function isDomain(input) {
     return input !== null && typeof input === 'object' && admittedDomains.has(input);
 }
-/** Retain source provenance without losing the admitted Domain identity. */
+/** Retain source provenance without losing the admitted root Domain identity. */
 export function createSourceDomain(domain, source) {
     if (!isDomain(domain))
         throw new TypeError('Source provenance requires an admitted Domain.');
@@ -14,12 +14,129 @@ export function createSourceDomain(domain, source) {
     admittedDomains.add(resolved);
     return resolved;
 }
+/** Construct one resolved Definition universe and one memoized facade per closure Domain. */
 export function createDomain(input) {
-    const classesByKey = createClasses(input.definitions, input.validation);
+    const entries = new Map();
+    for (const entry of input.entries) {
+        if (entries.has(entry.origin))
+            throw new TypeError(`Domain entry ${entry.origin} is duplicated.`);
+        entries.set(entry.origin, entry);
+    }
+    const root = entries.get(input.root.origin);
+    if (root === undefined || root.revision !== input.root.revision) {
+        throw new TypeError('Domain root is absent or has the wrong revision.');
+    }
+    const declarations = Object.freeze(input.entries.flatMap(({ definitions }) => definitions));
+    const classesByKey = createClasses(declarations, input.validation);
+    const definitionsByKey = createDefinitions(declarations, classesByKey, input);
+    const callables = createCallables(definitionsByKey, classesByKey);
+    const facades = new Map();
+    const projecting = new Set();
+    const project = (entry) => {
+        const cached = facades.get(entry.origin);
+        if (cached !== undefined)
+            return cached;
+        if (projecting.has(entry.origin))
+            throw new TypeError(`Dependency cycle reaches ${entry.origin}.`);
+        projecting.add(entry.origin);
+        const visibleEntries = reachableEntries(entry, entries);
+        const visibleOrigins = new Set(visibleEntries.map(({ origin }) => origin));
+        const local = [...definitionsByKey.values()]
+            .filter(({ ref }) => ref.origin === entry.origin)
+            .sort((left, right) => compare(left.key, right.key));
+        const classes = namespace(local, 'class');
+        const functions = namespace(local, 'function');
+        const policies = namespace(local, 'policy');
+        const views = namespace(local, 'view');
+        const coreNodes = namespace(local, 'core');
+        const domainEndpoint = Object.freeze({
+            kind: 'domain',
+            origin: entry.origin,
+        });
+        const coreEdges = Object.freeze(entry.coreEdges.map((edge) => {
+            const classValue = classesByKey.get(Key.of(edge.class));
+            if (classValue?.kind !== 'edge') {
+                throw new TypeError(`Core Edge has no Edge Class ${Key.of(edge.class)}.`);
+            }
+            return Object.freeze({
+                class: classValue,
+                source: edge.source.kind === 'domain'
+                    ? domainEndpoint
+                    : requiredCore(definitionsByKey, edge.source),
+                target: edge.target.kind === 'domain'
+                    ? domainEndpoint
+                    : requiredCore(definitionsByKey, edge.target),
+                properties: edge.properties,
+            });
+        }));
+        const dependencies = frozenRecord(Object.entries(entry.dependencies).map(([alias, pin]) => {
+            const dependency = entries.get(pin.origin);
+            if (dependency === undefined || dependency.revision !== pin.revision) {
+                throw new TypeError(`Dependency alias ${alias} has no exact ${pin.origin}@${pin.revision} entry.`);
+            }
+            return [alias, project(dependency)];
+        }));
+        const definitionLookup = ((value) => {
+            const resolved = definitionsByKey.get(typeof value === 'string' ? value : Key.of(value));
+            return resolved !== undefined && visibleOrigins.has(resolved.ref.origin)
+                ? resolved
+                : undefined;
+        });
+        const domain = {
+            origin: entry.origin,
+            revision: entry.revision,
+            closure: Object.freeze(visibleEntries
+                .map(({ origin, revision }) => Object.freeze({ origin, revision }))
+                .sort((left, right) => compare(left.origin, right.origin))),
+            dependencies,
+            classes,
+            functions,
+            policies,
+            views,
+            core: Object.freeze({ nodes: coreNodes, edges: coreEdges }),
+            definition: definitionLookup,
+            callable(key) {
+                const callable = callables.get(key);
+                if (callable === undefined)
+                    return undefined;
+                const origin = 'ref' in callable ? callable.ref.origin : callable.owner.ref.origin;
+                return visibleOrigins.has(origin) ? callable : undefined;
+            },
+            definitions(kind) {
+                return kind === undefined ? local : local.filter(({ ref }) => ref.kind === kind);
+            },
+            viewsFor(target) {
+                return Object.freeze(Object.values(views).filter((view) => {
+                    if (view.target.kind === 'domain')
+                        return target === 'domain';
+                    if (target === 'domain')
+                        return false;
+                    return view.target.definitions.some((ref) => {
+                        const selected = classesByKey.get(Key.of(ref));
+                        if (target.kind === 'node' && selected?.kind === 'node') {
+                            return target.satisfies(selected);
+                        }
+                        if (target.kind === 'edge' && selected?.kind === 'edge') {
+                            return target.satisfies(selected);
+                        }
+                        return false;
+                    });
+                }));
+            },
+        };
+        const admitted = Object.freeze(domain);
+        facades.set(entry.origin, admitted);
+        admittedDomains.add(admitted);
+        projecting.delete(entry.origin);
+        return admitted;
+    };
+    return project(root);
+}
+function createDefinitions(declarations, classesByKey, input) {
     const definitionsByKey = new Map();
     for (const value of classesByKey.values())
         definitionsByKey.set(value.key, value);
-    for (const definition of input.definitions) {
+    for (const definition of declarations) {
         if (definition.ref.kind === 'class')
             continue;
         if (isFunctionDefinition(definition)) {
@@ -44,35 +161,33 @@ export function createDomain(input) {
         }
         if (isPolicyDefinition(definition)) {
             const key = Key.of(definition.ref);
-            const resolved = Object.freeze({
+            definitionsByKey.set(key, Object.freeze({
                 ref: definition.ref,
                 key,
                 expression: definition.expression,
                 description: definition.description,
                 definition,
-            });
-            definitionsByKey.set(key, resolved);
+            }));
             continue;
         }
         if (isViewDefinition(definition)) {
             const key = Key.of(definition.ref);
-            const resolved = Object.freeze({
+            definitionsByKey.set(key, Object.freeze({
                 ref: definition.ref,
                 key,
                 target: definition.target,
                 description: definition.description,
                 definition,
-            });
-            definitionsByKey.set(key, resolved);
-            continue;
+            }));
         }
     }
-    for (const definition of input.definitions) {
+    for (const definition of declarations) {
         if (!isCoreDefinition(definition))
             continue;
         const classValue = classesByKey.get(Key.of(definition.class));
-        if (classValue?.kind !== 'node')
+        if (classValue?.kind !== 'node') {
             throw new TypeError(`Core ${Key.of(definition.ref)} has no Node Class.`);
+        }
         if (classValue.abstract) {
             throw new TypeError(`Core ${Key.of(definition.ref)} cannot use abstract Class ${classValue.key}.`);
         }
@@ -85,84 +200,41 @@ export function createDomain(input) {
         });
         definitionsByKey.set(resolved.key, resolved);
     }
-    const local = [...definitionsByKey.values()]
-        .filter(({ ref }) => ref.origin === input.origin)
-        .sort((left, right) => compare(left.key, right.key));
-    const classes = namespace(local, 'class');
-    const functions = namespace(local, 'function');
-    const policies = namespace(local, 'policy');
-    const views = namespace(local, 'view');
-    const coreNodes = namespace(local, 'core');
-    const domainEndpoint = Object.freeze({
-        kind: 'domain',
-        origin: input.origin,
-    });
-    const coreEdges = Object.freeze(input.coreEdges.map((edge) => {
-        const classValue = classesByKey.get(Key.of(edge.class));
-        if (classValue?.kind !== 'edge')
-            throw new TypeError(`Core Edge has no Edge Class ${Key.of(edge.class)}.`);
-        return Object.freeze({
-            class: classValue,
-            source: edge.source.kind === 'domain'
-                ? domainEndpoint
-                : requiredCore(definitionsByKey, edge.source),
-            target: edge.target.kind === 'domain'
-                ? domainEndpoint
-                : requiredCore(definitionsByKey, edge.target),
-            properties: edge.properties,
-        });
-    }));
+    return definitionsByKey;
+}
+function createCallables(definitions, classes) {
     const callables = new Map();
-    for (const definition of definitionsByKey.values()) {
-        if (definition.ref.kind === 'function')
+    for (const definition of definitions.values()) {
+        if (definition.ref.kind === 'function') {
             callables.set(definition.key, definition);
+        }
     }
-    for (const definition of classesByKey.values()) {
+    for (const definition of classes.values()) {
         if (definition.kind !== 'node')
             continue;
-        for (const method of [...definition.methods, ...definition.static.methods])
+        for (const method of [...definition.methods, ...definition.static.methods]) {
             callables.set(method.key, method);
+        }
     }
-    const definitionLookup = ((value) => definitionsByKey.get(typeof value === 'string' ? value : Key.of(value)));
-    const domain = {
-        origin: input.origin,
-        revision: input.revision,
-        closure: Object.freeze(input.closure.map(({ origin, revision }) => Object.freeze({ origin, revision }))),
-        dependencies: Object.freeze(input.dependencies.map(({ origin, revision }) => Object.freeze({ origin, revision }))),
-        classes,
-        functions,
-        policies,
-        views,
-        core: Object.freeze({ nodes: coreNodes, edges: coreEdges }),
-        definition: definitionLookup,
-        callable(key) {
-            return callables.get(key);
-        },
-        definitions(kind) {
-            return kind === undefined ? local : local.filter(({ ref }) => ref.kind === kind);
-        },
-        viewsFor(target) {
-            return Object.freeze(Object.values(views).filter((view) => {
-                if (view.target.kind === 'domain')
-                    return target === 'domain';
-                if (target === 'domain')
-                    return false;
-                return view.target.definitions.some((ref) => {
-                    const selected = classesByKey.get(Key.of(ref));
-                    if (target.kind === 'node' && selected?.kind === 'node') {
-                        return target.satisfies(selected);
-                    }
-                    if (target.kind === 'edge' && selected?.kind === 'edge') {
-                        return target.satisfies(selected);
-                    }
-                    return false;
-                });
-            }));
-        },
-    };
-    const admitted = Object.freeze(domain);
-    admittedDomains.add(admitted);
-    return admitted;
+    return callables;
+}
+function reachableEntries(root, entries) {
+    const reachable = new Map();
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (reachable.has(current.origin))
+            continue;
+        reachable.set(current.origin, current);
+        for (const dependency of Object.values(current.dependencies)) {
+            const nested = entries.get(dependency.origin);
+            if (nested === undefined || nested.revision !== dependency.revision) {
+                throw new TypeError(`Domain universe has no exact ${dependency.origin}@${dependency.revision}.`);
+            }
+            pending.push(nested);
+        }
+    }
+    return [...reachable.values()];
 }
 function namespace(definitions, kind) {
     return frozenRecord(definitions
@@ -190,4 +262,3 @@ function isCoreDefinition(value) {
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=create.js.map

package/dist/v1/domain/index.d.ts

@@ -1,3 +1,2 @@
 export { isDomain } from './create.js';
 export type * from './model/domain.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/domain/index.js

@@ -1,2 +1 @@
 export { isDomain } from './create.js';
-//# sourceMappingURL=index.js.map

package/dist/v1/domain/model/domain.d.ts

@@ -14,12 +14,18 @@ export interface CoreNamespace<Nodes extends Readonly<Record<string, unknown>> =
     readonly nodes: Readonly<Nodes>;
     readonly edges: readonly ResolvedCoreEdge[];
 }
+/** Erased recursive dependency projection used when no authored Schema witness is available. */
+export interface DependencyDomains {
+    readonly [alias: string]: Domain<Readonly<Record<string, AnyResolvedClass>>, Readonly<Record<string, ResolvedFunction>>, Readonly<Record<string, ResolvedPolicy>>, Readonly<Record<string, ResolvedView>>, Readonly<Record<string, ResolvedCoreDefinition>>, Revision>;
+}
+export type DependencyDomainNamespace<Dependencies extends Readonly<Record<string, unknown>> = DependencyDomains> = Readonly<Dependencies>;
 export interface Domain<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, AnyResolvedClass>>, Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedFunction>>, Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedPolicy>>, Views extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedView>>, CoreNodes extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedCoreDefinition>>, RevisionValue extends Revision = Revision> {
     readonly origin: Key.Origin;
     readonly revision: RevisionValue;
     /** Exact admitted root and transitive dependency revisions, ordered by origin. */
     readonly closure: readonly DomainDependency[];
-    readonly dependencies: readonly DomainDependency[];
+    /** Exact immutable direct dependency Domains keyed by authored Schema aliases. */
+    readonly dependencies: DependencyDomainNamespace;
     readonly classes: ClassNamespace<Classes>;
     readonly functions: FunctionNamespace<Functions>;
     readonly policies: PolicyNamespace<Policies>;
@@ -32,7 +38,13 @@ export interface Domain<Classes extends Readonly<Record<string, unknown>> = Read
     definitions<const Kind extends DefinitionRef['kind']>(kind: Kind): readonly ResolvedDefinitionOf<Kind>[];
     viewsFor(target: 'domain' | AnyResolvedClass): readonly Views[keyof Views][];
 }
-export type SourceDomain<Source, Resolved = Domain> = Resolved & {
+declare const DOMAIN_SOURCE_RESOLVED: unique symbol;
+/** Type-only witness carried by a source that retains its exact resolved Domain. */
+export interface DomainSource<Resolved extends Domain = Domain> {
+    readonly [DOMAIN_SOURCE_RESOLVED]: Resolved;
+}
+export type DomainOfSource<Source> = Source extends DomainSource<infer Resolved> ? Resolved : Domain;
+export type SourceDomain<Source, Resolved extends Domain = DomainOfSource<Source>> = Resolved & {
     readonly source: Source;
 };
 export type ClassesOf<Value> = Value extends Domain<infer Classes> ? Classes : never;
@@ -44,4 +56,4 @@ export type PoliciesOf<Value> = Value extends Domain<Readonly<Record<string, unk
 export type ViewsOf<Value> = Value extends Domain<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, infer Views> ? Views : never;
 export type PropertyInputFor<Class extends AnyResolvedClass> = import('../../language/class/resolved.js').PropertyInputOf<Class>;
 export type PropertyValuesFor<Class extends AnyResolvedClass> = ReturnType<Class['properties']['from']>;
-//# sourceMappingURL=domain.d.ts.map
+export {};

package/dist/v1/domain/model/domain.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=domain.js.map

package/dist/v1/domain/model/input.d.ts

@@ -1,17 +1,21 @@
 import type { Key as AddressKey, PropertyKey, Revision } from '../../addressing/index.js';
-import type { DomainDependency } from '../../addressing/index.js';
+import type { DomainDependency, DomainDependencyMap } from '../../addressing/index.js';
 import type { CoreEdge } from '../../language/core/model/core.js';
 import type { Definition } from '../../language/definition.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
-/** Dependency-closed, representation-neutral input to the one Domain constructor. */
-export interface DomainInput {
+/** One admitted Schema entry in a dependency-closed Domain universe. */
+export interface DomainEntryInput {
     readonly origin: AddressKey.Origin;
     readonly revision: Revision;
-    readonly closure: readonly DomainDependency[];
-    readonly dependencies: readonly DomainDependency[];
+    readonly dependencies: DomainDependencyMap;
     readonly definitions: readonly Definition[];
     readonly coreEdges: readonly CoreEdge[];
+}
+/** Dependency-closed, representation-neutral input to the one Domain universe constructor. */
+export interface DomainInput {
+    readonly root: DomainDependency;
+    readonly entries: readonly DomainEntryInput[];
     readonly validation: DomainValidation;
 }
 /** Already-bound validation semantics supplied by source compilation or compiled loading. */
@@ -25,4 +29,3 @@ export interface DomainValidation {
     callableInputField(key: AddressKey.Callable, field: string, input: unknown): readonly Diagnostic[];
     callableOutput(key: AddressKey.Callable, output: unknown): readonly Diagnostic[];
 }
-//# sourceMappingURL=input.d.ts.map

package/dist/v1/domain/model/input.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=input.js.map

package/dist/v1/domain/namespace/member-collection.d.ts

@@ -3,4 +3,3 @@ import type { ResolvedProperty, ResolvedPropertyCollection } from '../../languag
 export declare function createPropertyCollection(values: Iterable<ResolvedProperty>): ResolvedPropertyCollection;
 export declare function createMethodCollection(values: Iterable<ResolvedMethod>): ResolvedMethodCollection;
 export declare function frozenRecord<Value>(entries: Iterable<readonly [string, Value]>): Readonly<Record<string, Value>>;
-//# sourceMappingURL=member-collection.d.ts.map

package/dist/v1/domain/namespace/member-collection.js

@@ -79,4 +79,3 @@ export function frozenRecord(entries) {
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=member-collection.js.map

package/dist/v1/domain/projection/classes.d.ts

@@ -2,4 +2,3 @@ import type { AnyResolvedClass } from '../../language/class/resolved.js';
 import type { Definition } from '../../language/definition.js';
 import type { DomainValidation } from '../model/input.js';
 export declare function createClasses(definitions: readonly Definition[], validation: DomainValidation): ReadonlyMap<string, AnyResolvedClass>;
-//# sourceMappingURL=classes.d.ts.map

package/dist/v1/domain/projection/classes.js

@@ -198,4 +198,3 @@ function validateProperties(abstract, properties, input) {
     }
     return Object.freeze(diagnostics);
 }
-//# sourceMappingURL=classes.js.map

package/dist/v1/domain/validation/create.d.ts

@@ -16,4 +16,3 @@ export interface CallableValidation {
 export declare function createDomainValidation(properties: ReadonlyMap<PropertyKey, PropertyValidation>, callables: ReadonlyMap<Key.Callable, CallableValidation>): DomainValidation;
 export declare function combineDomainValidation(values: readonly DomainValidation[]): DomainValidation;
 export declare function unknownInputField(field: string): readonly Diagnostic[];
-//# sourceMappingURL=create.d.ts.map

package/dist/v1/domain/validation/create.js

@@ -73,4 +73,3 @@ function unknownTarget(kind, key) {
         }),
     ];
 }
-//# sourceMappingURL=create.js.map

package/dist/v1/index.d.ts

@@ -14,4 +14,3 @@ export type { PropertyValues as PropertyValuesValue } from './language/index.js'
 export type { CompiledSchema } from './compiled/index.js';
 export * as schema from './schema/index.js';
 export * as bundle from './bundle/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/index.js

@@ -6,4 +6,3 @@ export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, is
 export { isDomain } from './domain/index.js';
 export * as schema from './schema/index.js';
 export * as bundle from './bundle/index.js';
-//# sourceMappingURL=index.js.map

package/dist/v1/language/callable/index.d.ts

@@ -1,3 +1,2 @@
 export type * from './model/callable.js';
 export type * from './resolved.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/language/callable/index.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=index.js.map

package/dist/v1/language/callable/model/callable.d.ts

@@ -31,4 +31,3 @@ export type MethodDefinition = CallableDefinition & {
     readonly inheritance: MethodInheritance;
 };
 export type MethodRecord = Readonly<Record<string, MethodDefinition>>;
-//# sourceMappingURL=callable.d.ts.map

package/dist/v1/language/callable/model/callable.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=callable.js.map

package/dist/v1/language/callable/resolved.d.ts

@@ -66,4 +66,3 @@ type MethodOwnerKeyOfKey<ExactKey extends MethodKey> = ExactKey extends `${infer
 export type CallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
 export type CallableOutputOf<Callable> = Callable extends ResolvedMethod<unknown, infer Output, boolean> ? Output : Callable extends ResolvedFunction<unknown, infer Output> ? Output : never;
 export {};
-//# sourceMappingURL=resolved.d.ts.map

package/dist/v1/language/callable/resolved.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=resolved.js.map

package/dist/v1/language/class/facets.d.ts

@@ -56,4 +56,3 @@ export type MethodAccessOf<Class, Binary = unknown> = {
     };
 };
 export {};
-//# sourceMappingURL=facets.d.ts.map

package/dist/v1/language/class/facets.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=facets.js.map

package/dist/v1/language/class/index.d.ts

@@ -6,4 +6,3 @@ export { PropertyValues } from './property-values.js';
 export type { PropertyValuesOperations } from './property-values.js';
 export type * from './facets.js';
 export type * from './resolved.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/language/class/index.js

@@ -1,2 +1 @@
 export { PropertyValues } from './property-values.js';
-//# sourceMappingURL=index.js.map

package/dist/v1/language/class/model/class.d.ts

@@ -34,4 +34,3 @@ export type DirectedEdgeDefinition = Extract<EdgeClassDefinition, {
 export type UndirectedEdgeDefinition = Extract<EdgeClassDefinition, {
     readonly orientation: 'undirected';
 }>;
-//# sourceMappingURL=class.d.ts.map

package/dist/v1/language/class/model/class.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=class.js.map

package/dist/v1/language/class/model/data.d.ts

@@ -9,4 +9,3 @@ export type DataDefinition = JsonObject & {
 export interface DataFacet {
     readonly data?: DataDefinition;
 }
-//# sourceMappingURL=data.d.ts.map

package/dist/v1/language/class/model/data.js

@@ -1,3 +1,2 @@
 /** Canonical lowercase RFC 6838 media type without parameters. */
 export const MEDIA_TYPE_PATTERN = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,126}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,126}$/u;
-//# sourceMappingURL=data.js.map

package/dist/v1/language/class/model/edge.d.ts

@@ -36,4 +36,3 @@ export interface UndirectedEdgeContract {
     readonly constraints: UndirectedEdgeConstraints;
 }
 export type EdgeContract = DirectedEdgeContract | UndirectedEdgeContract;
-//# sourceMappingURL=edge.d.ts.map

package/dist/v1/language/class/model/edge.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=edge.js.map

package/dist/v1/language/class/model/property.d.ts

@@ -16,4 +16,3 @@ export type PropertyRecord = Readonly<Record<string, PropertyDefinition>>;
 export interface PropertyFacet {
     readonly properties: PropertyRecord;
 }
-//# sourceMappingURL=property.d.ts.map

package/dist/v1/language/class/model/property.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=property.js.map

package/dist/v1/language/class/property-values.d.ts

@@ -13,4 +13,3 @@ export declare function acceptPropertyValues(input: unknown, pointer?: string):
 export declare function createPropertyValues(entries: Iterable<readonly [PropertyKey, PortableValue]>): PropertyValues;
 export declare const PropertyValues: PropertyValuesOperations;
 export {};
-//# sourceMappingURL=property-values.d.ts.map

package/dist/v1/language/class/property-values.js

@@ -28,4 +28,3 @@ function freeze(value) {
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=property-values.js.map

package/dist/v1/language/class/resolved.d.ts

@@ -121,4 +121,3 @@ type PropertyByNameOf<Class> = Readonly<{
     [Name in Exclude<keyof PropertiesOf<Class>, keyof ResolvedPropertyCollection>]: Extract<PropertiesOf<Class>[Name], ResolvedProperty>;
 }>;
 export {};
-//# sourceMappingURL=resolved.d.ts.map

package/dist/v1/language/class/resolved.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=resolved.js.map

package/dist/v1/language/core/index.d.ts

@@ -1,3 +1,2 @@
 export type * from './model/core.js';
 export type * from './resolved.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/language/core/index.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=index.js.map

package/dist/v1/language/core/model/core.d.ts

@@ -18,4 +18,3 @@ export interface CoreContent {
     readonly nodes: Readonly<Record<string, CoreDefinition>>;
     readonly edges: readonly CoreEdge[];
 }
-//# sourceMappingURL=core.d.ts.map

package/dist/v1/language/core/model/core.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=core.js.map

package/dist/v1/language/core/resolved.d.ts

@@ -19,4 +19,3 @@ export interface ResolvedCoreEdge {
     readonly target: ResolvedCoreDefinition | ResolvedDomainEndpoint;
     readonly properties: PropertyValues;
 }
-//# sourceMappingURL=resolved.d.ts.map

package/dist/v1/language/core/resolved.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=resolved.js.map

package/dist/v1/language/definition/metadata.d.ts

@@ -10,4 +10,3 @@ export declare const icon: Readonly<{
     readonly minLength: 1;
     readonly maxLength: 8000;
 }>;
-//# sourceMappingURL=metadata.d.ts.map

package/dist/v1/language/definition/metadata.js

@@ -10,4 +10,3 @@ export const icon = Object.freeze({
     minLength: 1,
     maxLength: 8000,
 });
-//# sourceMappingURL=metadata.js.map

package/dist/v1/language/definition.d.ts

@@ -5,4 +5,3 @@ import type { PolicyDefinition } from './policy/model/policy.js';
 import type { ViewDefinition } from './view/model/view.js';
 /** Every named V1 product Definition. Property and Method remain Class-owned members. */
 export type Definition = ClassDefinition | FunctionDefinition | PolicyDefinition | ViewDefinition | CoreDefinition;
-//# sourceMappingURL=definition.d.ts.map

package/dist/v1/language/definition.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=definition.js.map

package/dist/v1/language/index.d.ts

@@ -21,4 +21,3 @@ export type * from './policy/model/policy.js';
 export type * from './policy/resolved.js';
 export type * from './view/model/view.js';
 export type * from './view/resolved.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/language/index.js

@@ -1,2 +1 @@
 export { PropertyValues } from './class/property-values.js';
-//# sourceMappingURL=index.js.map

package/dist/v1/language/policy/analysis/branches.d.ts

@@ -17,4 +17,3 @@ export declare function capBranches(values: readonly PatternBranch[]): readonly
 export declare function isConnected(branch: PatternBranch): boolean;
 export declare function targetMode(branch: PatternBranch): PolicyTargetMode | undefined;
 export declare function termKey(term: PolicyPatternTerm, namespace: string): string;
-//# sourceMappingURL=branches.d.ts.map