@astrale-os/sdk 0.5.0-beta.99 → 0.6.0-beta.0

package/dist/platform/schema/class-icon.d.ts

@@ -0,0 +1,15 @@
+import type { LucideIconData } from '@lucide/icons';
+declare const CLASS_ICON: unique symbol;
+/** An admitted, self-contained SVG suitable for a Node Class presentation icon. */
+export type ClassIcon = string & {
+    readonly [CLASS_ICON]: true;
+};
+/** Stable empty SVG used when an author explicitly chooses to render no icon glyph. */
+export declare const NEUTRAL_CLASS_ICON_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"></svg>";
+/** Framework-neutral constructors for canonical Node Class icons. */
+export declare const classIcon: Readonly<{
+    readonly neutral: ClassIcon;
+    svg(source: string): ClassIcon;
+    lucide(icon: LucideIconData): ClassIcon;
+}>;
+export {};

package/dist/platform/schema/class-icon.js

@@ -0,0 +1,46 @@
+import { buildLucideSvg } from '@lucide/icons/build';
+const MAX_CLASS_ICON_LENGTH = 8_000;
+const SVG_ROOT = /^<svg(?:\s[^>]*)?>[\s\S]*<\/svg>$/u;
+const SVG_ROOT_OPEN = /<svg(?:\s|>)/gu;
+const SVG_ROOT_CLOSE = /<\/svg\s*>/gu;
+const SVG_GRAPHIC = /<(?:circle|ellipse|line|path|polygon|polyline|rect)\b/iu;
+const UNSAFE_SVG = /<\s*(?:animate|discard|embed|foreignObject|iframe|image|object|script|set|style|use)\b|<!DOCTYPE\b|<!ENTITY\b|\son[a-z][\w:.-]*\s*=|(?:href|xlink:href)\s*=|javascript\s*:|url\s*\(/iu;
+/** Stable empty SVG used when an author explicitly chooses to render no icon glyph. */
+export const NEUTRAL_CLASS_ICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"></svg>';
+function svg(source) {
+    if (typeof source !== 'string') {
+        throw new TypeError('Class icon must be an inline SVG string.');
+    }
+    const value = source.trim();
+    if (Array.from(value).length > MAX_CLASS_ICON_LENGTH) {
+        throw new TypeError(`Class icon must contain at most ${MAX_CLASS_ICON_LENGTH} characters.`);
+    }
+    if (!SVG_ROOT.test(value) ||
+        (value.match(SVG_ROOT_OPEN)?.length ?? 0) !== 1 ||
+        (value.match(SVG_ROOT_CLOSE)?.length ?? 0) !== 1) {
+        throw new TypeError('Class icon must be one complete inline <svg> element.');
+    }
+    if (UNSAFE_SVG.test(value)) {
+        throw new TypeError('Class icon SVG must be self-contained and contain no executable content.');
+    }
+    if (value !== NEUTRAL_CLASS_ICON_SVG && !SVG_GRAPHIC.test(value)) {
+        throw new TypeError('Class icon SVG must contain a visible vector element.');
+    }
+    return value;
+}
+function lucide(icon) {
+    let source;
+    try {
+        source = buildLucideSvg(icon, { color: 'currentColor' });
+    }
+    catch (cause) {
+        throw new TypeError('Class icon must be valid Lucide icon data.', { cause });
+    }
+    return svg(source);
+}
+/** Framework-neutral constructors for canonical Node Class icons. */
+export const classIcon = Object.freeze({
+    neutral: svg(NEUTRAL_CLASS_ICON_SVG),
+    svg,
+    lucide,
+});

package/dist/platform/schema/error.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export type DeclaredErrorFamily = 'VALIDATION_ERROR' | 'NOT_FOUND' | 'CONFLICT' | 'UNSUPPORTED';
+export interface DeclaredErrorDefinition<out Details extends z.ZodType = z.ZodType> {
+    readonly family: DeclaredErrorFamily;
+    readonly message: string;
+    readonly details: Details;
+}
+/** Declare a reusable business-error contract. Its registration key supplies the code. */
+export declare function error<const Definition extends DeclaredErrorDefinition>(definition: Definition & Record<Exclude<keyof Definition, keyof DeclaredErrorDefinition>, never>): Readonly<Definition>;
+/** Shared admission for Schema declarations and Action/Workflow registration. */
+export declare function acceptErrorDefinition(input: unknown, label?: string): DeclaredErrorDefinition;

package/dist/platform/schema/error.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+const MAXIMUM_MESSAGE_BYTES = 512;
+const FAMILIES = new Set([
+    'VALIDATION_ERROR',
+    'NOT_FOUND',
+    'CONFLICT',
+    'UNSUPPORTED',
+]);
+/** Declare a reusable business-error contract. Its registration key supplies the code. */
+export function error(definition) {
+    return acceptErrorDefinition(definition);
+}
+/** Shared admission for Schema declarations and Action/Workflow registration. */
+export function acceptErrorDefinition(input, label = 'Error declaration') {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError(`${label} is invalid.`);
+    }
+    const candidate = input;
+    if (Reflect.ownKeys(candidate).length !== 3 ||
+        !Object.hasOwn(candidate, 'family') ||
+        !Object.hasOwn(candidate, 'message') ||
+        !Object.hasOwn(candidate, 'details')) {
+        throw new TypeError(`${label} is invalid.`);
+    }
+    const { family, message, details } = candidate;
+    if (!FAMILIES.has(family) ||
+        typeof message !== 'string' ||
+        message.trim() === '' ||
+        new TextEncoder().encode(message).byteLength > MAXIMUM_MESSAGE_BYTES ||
+        !(details instanceof z.ZodType)) {
+        throw new TypeError(`${label} is invalid.`);
+    }
+    return Object.freeze({ family: family, message, details });
+}

package/dist/platform/schema/errors/index.d.ts

@@ -0,0 +1,3 @@
+/** Runtime-safe business-error declarations shared by Schema and handlers. */
+export { error } from '../error.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFamily } from '../error.js';

package/dist/platform/schema/errors/index.js

@@ -0,0 +1,2 @@
+/** Runtime-safe business-error declarations shared by Schema and handlers. */
+export { error } from '../error.js';

package/dist/platform/schema/icons/index.d.ts

@@ -0,0 +1,2 @@
+/** Framework-neutral Lucide icon data accepted by `classIcon.lucide`. */
+export * from '@lucide/icons';

package/dist/platform/schema/icons/index.js

@@ -0,0 +1,2 @@
+/** Framework-neutral Lucide icon data accepted by `classIcon.lucide`. */
+export * from '@lucide/icons';

package/dist/platform/schema/index.d.ts

@@ -1,18 +1,25 @@
-import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
+/** Canonical Schema authoring, compilation, loading, and resolved Domain surface. */
 export * from '@astrale-os/kernel-dsl/v1';
+export { defineSchema } from './schema-authoring.js';
+export type { AuthoredSchema, AuthoredDomain } from './schema-authoring.js';
+export { stateProperty } from './state-property.js';
+export type { StateProperty } from './state-property.js';
+export { property } from './property.js';
+export type { AuthoredProperty, PropertyOptions } from './property.js';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
-export type { CallablePolicyBuilder, CallablePolicyContext, CallableProjection, AuthoredMethodProjection, AuthoredPropertyProjection, ClassIdentityProjection, ClassOwnerProjection, CoreEdge, CoreEndpoint, CoreNode, DefinedSchema, DirectedEdgeClass, ClassReferenceProjection, ClassProjection, FunctionProjection, EdgeClass, Function, Method, MethodProjection, Lazy, NodeClass, Policy, Property, PropertyProjection, ResolvedDomainOfInput, View, } from '@astrale-os/kernel-dsl/v1/builder';
+export { defineClass, nodeClass } from './class-authoring.js';
+export type { AuthoredNodeClass, NodeClassInput } from './class-authoring.js';
+export { error } from './error.js';
+export type { DeclaredErrorDefinition, DeclaredErrorFamily } from './error.js';
+export { classIcon } from './class-icon.js';
+export type { ClassIcon } from './class-icon.js';
+export type { CallablePolicyBuilder, CallablePolicyContext, CallableProjection, AuthoredMethodProjection, AuthoredPropertyProjection, ClassIdentityProjection, ClassOwnerProjection, CoreEdge, CoreEndpoint, CoreNode, DefinedSchema, DirectedEdgeClass, ClassReferenceProjection, ClassProjection, FunctionProjection, EdgeClass, Function, Method, MethodProjection, Lazy, NodeClass, Policy, PolicyExistsContext, PolicyNodeBinder, PolicyPatternContext, Property, PropertyProjection, ResolvedDomainOfInput, View, } from '@astrale-os/kernel-dsl/v1/builder';
 export type { Array, Object, Value } from '@astrale-os/kernel-dsl/value';
-export type { ClassKind, DirectedEdgeContract, EdgeClassPolicies, NodeClassDefinition, PolicyCheckObject, PropertyFacet, UndirectedEdgeContract, } from '@astrale-os/kernel-dsl/v1/language';
+export type { ClassKind, DirectedEdgeContract, EdgeClassPolicies, NodeClassDefinition, PolicyCheckObject, PolicyObjectRef, PropertyFacet, StateTopology, UndirectedEdgeContract, } from '@astrale-os/kernel-dsl/v1/language';
 export type { DomainSchema } from '@astrale-os/kernel-dsl/v1/schema';
 /** Kernel-owned Schema values used by authored product Schemas and graph operations. */
-export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
-export type { AuthorityOperation, AuthorityRelation, Kernel } from '@astrale-os/kernel-core/schema';
-/**
- * Re-admit the Kernel Schema into the SDK's DSL instance. Package-manager trees may retain a
- * different DSL instance below Kernel Core; acceptance context is intentionally process-local.
- * The SDK-owned interface also gives downstream declaration emit a portable public type name.
- */
-export interface KernelSchema extends CoreKernelSchema {
-}
-export declare const KernelSchema: KernelSchema;
+export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, KernelRootFunctions, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
+export type { AuthorityOperation, AuthorityRelation } from '@astrale-os/kernel-core/schema';
+export { K, KernelSchema } from './kernel.js';
+export type { Kernel, KernelClass, KernelDomain } from './kernel.js';
+export { nodeId } from './node-id.js';

package/dist/platform/schema/index.js

@@ -1,8 +1,13 @@
-import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
 /** Canonical Schema authoring, compilation, loading, and resolved Domain surface. */
-import { schema as language } from '@astrale-os/kernel-dsl/v1';
 export * from '@astrale-os/kernel-dsl/v1';
+export { defineSchema } from './schema-authoring.js';
+export { stateProperty } from './state-property.js';
+export { property } from './property.js';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+export { defineClass, nodeClass } from './class-authoring.js';
+export { error } from './error.js';
+export { classIcon } from './class-icon.js';
 /** Kernel-owned Schema values used by authored product Schemas and graph operations. */
-export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, K, KernelRootFunctions, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
-export const KernelSchema = language.accept(CoreKernelSchema);
+export { AuthorityOperationOrder, AuthorityOperations, AuthorityRelations, KernelRootFunctions, OperationCore, operationOf, } from '@astrale-os/kernel-core/schema';
+export { K, KernelSchema } from './kernel.js';
+export { nodeId } from './node-id.js';

package/dist/platform/schema/kernel.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import type { DefinedSchema } from '@astrale-os/kernel-dsl/v1/builder';
+import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
+import { schema } from '@astrale-os/kernel-dsl/v1';
+type KernelClasses = schema.DomainOf<CoreKernelSchema>['classes'];
+/** A Kernel Class retains its canonical name instead of copying its resolved collections. */
+export interface KernelClass<Name extends keyof KernelClasses> extends Pick<KernelClasses[Name], keyof ResolvedClass> {
+    readonly key: `${CoreKernelSchema['origin']}:class.${Name}`;
+}
+/** The canonical Kernel Domain with reusable Class references. */
+export interface KernelDomain extends schema.DomainOf<CoreKernelSchema> {
+    readonly classes: {
+        readonly [Name in keyof KernelClasses]: KernelClass<Name>;
+    };
+}
+/** SDK-owned portable name for the Kernel Schema's exact contract. */
+export interface KernelSchema extends DefinedSchema<CoreKernelSchema['origin'], KernelDomain> {
+}
+export declare const KernelSchema: KernelSchema;
+export declare const K: schema.ResolvedDomainOf<KernelSchema>;
+export type Kernel = typeof K;
+export {};

package/dist/platform/schema/kernel.js

@@ -0,0 +1,5 @@
+import { K as CoreKernel, KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
+import { schema } from '@astrale-os/kernel-dsl/v1';
+// Admission belongs to the SDK's DSL instance, even when Core uses a different package instance.
+export const KernelSchema = schema.accept(CoreKernelSchema);
+export const K = CoreKernel;

package/dist/platform/schema/node-id.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+/** Bare Kernel node identity. Does not assert existence, Class, or authority. */
+export declare function nodeId(): z.ZodString;

package/dist/platform/schema/node-id.js

@@ -0,0 +1,6 @@
+import { fullMatch } from '@astrale-os/kernel-dsl/v1';
+import { z } from 'zod';
+/** Bare Kernel node identity. Does not assert existence, Class, or authority. */
+export function nodeId() {
+    return z.string().min(1).max(255).check(fullMatch('[A-Za-z0-9._-]+'));
+}

package/dist/platform/schema/property.d.ts

@@ -0,0 +1,12 @@
+import { type Property as CanonicalProperty, type ValueSchemaInput } from '@astrale-os/kernel-dsl/v1/builder';
+/** Stable SDK-owned options for ordinary Schema properties. */
+export interface PropertyOptions {
+    readonly required?: boolean;
+    readonly description?: string;
+}
+/** Keep canonical generic inference: ordinary properties carry no state machine. */
+export type AuthoredProperty<Schema extends ValueSchemaInput, Options extends PropertyOptions = Record<never, never>> = CanonicalProperty<Schema, Options, never>;
+/** Canonical property authoring with a portable inferred return type. */
+export declare const property: <const Schema extends ValueSchemaInput, const Options extends PropertyOptions = Record<never, never>>(schema: Schema, options?: Options) => AuthoredProperty<Schema, {
+    [Key in keyof Options]: Options[Key];
+}>;

package/dist/platform/schema/property.js

@@ -0,0 +1,3 @@
+import { property as canonicalProperty, } from '@astrale-os/kernel-dsl/v1/builder';
+/** Canonical property authoring with a portable inferred return type. */
+export const property = canonicalProperty;

package/dist/platform/schema/schema-authoring.d.ts

@@ -0,0 +1,48 @@
+import type { DefinedSchema, ResolvedDomainOfInput } from '@astrale-os/kernel-dsl/v1/builder';
+import type { DomainSchema } from '@astrale-os/kernel-dsl/v1/schema';
+import { defineSchema as kernelDefineSchema } from '@astrale-os/kernel-dsl/v1';
+type DomainSchemaInput = Parameters<typeof kernelDefineSchema>[1];
+declare const authoredGraph: unique symbol;
+/** Opaque legacy Schemas retain their witness; SDK Schemas retain authored input and edges. */
+type Entry = readonly [origin: string, schema: DomainSchema] | readonly [
+    origin: string,
+    input: DomainSchemaInput,
+    dependencies: Readonly<Record<string, string>>
+];
+type Dependencies<Input> = 'dependencies' extends keyof Input ? NonNullable<Input['dependencies']> : {};
+type GraphOf<Schema> = typeof authoredGraph extends keyof Schema ? Schema[typeof authoredGraph] extends infer Graph ? Graph extends Entry ? Graph : never : never : Schema extends DomainSchema<infer Origin> ? readonly [Origin, Schema] : never;
+type GraphOfInput<Origin extends string, Input extends DomainSchemaInput> = readonly [
+    Origin,
+    {
+        readonly [Key in keyof Input as Exclude<Key, 'dependencies'>]: Input[Key];
+    },
+    {
+        readonly [Alias in keyof Dependencies<Input>]: Dependencies<Input>[Alias] extends DomainSchema<infer DependencyOrigin> ? DependencyOrigin : never;
+    }
+] | {
+    [Alias in keyof Dependencies<Input>]: GraphOf<Dependencies<Input>[Alias]>;
+}[keyof Dependencies<Input>];
+type LastEntry<Graph> = (Graph extends unknown ? (entry: () => Graph) => void : never) extends (entry: infer Intersection) => void ? Intersection extends () => infer Last ? Last : never : never;
+type WithoutEquivalent<Graph, Selected> = Graph extends Selected ? Selected extends Graph ? never : Graph : Graph;
+type UniqueEntries<Graph, Selected = LastEntry<Graph>> = [Graph] extends [never] ? never : Selected | UniqueEntries<WithoutEquivalent<Graph, Selected>>;
+type InputOf<Origin extends string, Graph extends Entry> = Extract<Graph, readonly [Origin, DomainSchemaInput, Readonly<Record<string, string>>]> extends readonly [
+    string,
+    infer Input extends DomainSchemaInput,
+    infer Dependencies extends Readonly<Record<string, string>>
+] ? Input & {
+    readonly dependencies: {
+        readonly [Alias in keyof Dependencies]: SchemaOf<Dependencies[Alias], Graph>;
+    };
+} : never;
+type SchemaOf<Origin extends string, Graph extends Entry> = Extract<Graph, readonly [Origin, DomainSchema]> extends infer Legacy ? [Legacy] extends [never] ? AuthoredSchema<Origin, Graph> : Legacy extends readonly [string, infer Schema extends DomainSchema] ? Schema : never : never;
+/** Resolve a dependency graph without expanding a shared Schema at each dependency edge. */
+export interface AuthoredDomain<Origin extends string, Graph extends Entry> extends ResolvedDomainOfInput<Origin, InputOf<Origin, Graph>> {
+}
+/** A Schema retains each transitive author's input once, with dependency edges represented by origin. */
+export interface AuthoredSchema<Origin extends string, Graph extends Entry> extends DefinedSchema<Origin, AuthoredDomain<Origin, Graph>> {
+    readonly [authoredGraph]?: Graph;
+}
+type DefineSchema = <const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input) => string extends Origin | Extract<Dependencies<Input>[keyof Dependencies<Input>], DomainSchema>['origin'] ? DefinedSchema<Origin, ResolvedDomainOfInput<Origin, Input>> : AuthoredSchema<Origin, Extract<UniqueEntries<GraphOfInput<Origin, Input>>, Entry>>;
+/** The canonical implementation with a portable, automatically inferred declaration. */
+export declare const defineSchema: DefineSchema;
+export {};

package/dist/platform/schema/schema-authoring.js

@@ -0,0 +1,3 @@
+import { defineSchema as kernelDefineSchema } from '@astrale-os/kernel-dsl/v1';
+/** The canonical implementation with a portable, automatically inferred declaration. */
+export const defineSchema = kernelDefineSchema;

package/dist/platform/schema/state-property.d.ts

@@ -0,0 +1,11 @@
+import type { StateMachine } from '@astrale-os/kernel-dsl/v1/language/state';
+import { stateProperty as canonicalStateProperty, type PropertyOptions } from '@astrale-os/kernel-dsl/v1/builder';
+type StatePropertyOptions = Omit<PropertyOptions, 'required'>;
+/** Keep the machine's internal Zod schemas behind a portable public property handle. */
+export interface StateProperty<Machine extends StateMachine, Options extends StatePropertyOptions = Record<never, never>> extends ReturnType<typeof canonicalStateProperty<Machine, Options>> {
+}
+/** Canonical state-property authoring with a portable inferred return type. */
+export declare const stateProperty: <const Machine extends StateMachine, const Options extends StatePropertyOptions = Record<never, never>>(machine: Machine, options?: Options & Record<Exclude<keyof Options, 'description'>, never>) => StateProperty<Machine, {
+    [Key in keyof Options]: Options[Key];
+}>;
+export {};

package/dist/platform/schema/state-property.js

@@ -0,0 +1,3 @@
+import { stateProperty as canonicalStateProperty, } from '@astrale-os/kernel-dsl/v1/builder';
+/** Canonical state-property authoring with a portable inferred return type. */
+export const stateProperty = canonicalStateProperty;

package/dist/project/admit.d.ts

@@ -0,0 +1,4 @@
+import type { Project } from './project.js';
+export declare const PROJECT_EXPORT_HINT: string;
+/** Admit the module namespace of one loaded `astrale.config.ts`: exactly one default Project. */
+export declare function admitProjectModule(loaded: unknown): Project;

package/dist/project/admit.js

@@ -0,0 +1,22 @@
+import { isLegacyDeployment } from '../deployment/deploy.js';
+import { isProject } from './define.js';
+export const PROJECT_EXPORT_HINT = 'astrale.config.ts must export exactly one default Project:\n' +
+    "  import { defineProject } from '@astrale-os/sdk/project'\n" +
+    '  export default defineProject({ application, environments: { development: { deployment: adapter() } } })\n';
+/** Admit the module namespace of one loaded `astrale.config.ts`: exactly one default Project. */
+export function admitProjectModule(loaded) {
+    if (loaded === null ||
+        typeof loaded !== 'object' ||
+        Array.isArray(loaded) ||
+        !Object.hasOwn(loaded, 'default') ||
+        Object.keys(loaded).some((key) => key !== 'default')) {
+        throw new TypeError(PROJECT_EXPORT_HINT);
+    }
+    const value = Reflect.get(loaded, 'default');
+    if (isProject(value))
+        return value;
+    if (isLegacyDeployment(value)) {
+        throw new TypeError(`astrale.config.ts exports the legacy deploy() aggregate; migrate Application and Environments into defineProject().\n${PROJECT_EXPORT_HINT}`);
+    }
+    throw new TypeError(`Default export must be created by defineProject().\n${PROJECT_EXPORT_HINT}`);
+}

package/dist/project/define.d.ts

@@ -0,0 +1,12 @@
+import type { ApplicationIdentity } from '../application/index.js';
+import type { Tests } from '../testing/index.js';
+import type { Project, ProjectEnvironment, ProjectEntrypoints } from './project.js';
+export interface ProjectInput<ApplicationValue extends ApplicationIdentity, EnvironmentsValue extends Readonly<Record<string, ProjectEnvironment>>, TestsValue extends Tests | undefined> {
+    readonly application: ApplicationValue;
+    readonly environments: EnvironmentsValue;
+    readonly entrypoints?: ProjectEntrypoints;
+    readonly tests?: TestsValue;
+}
+/** Capture one inert Project definition without loading entrypoints or performing effects. */
+export declare function defineProject<const ApplicationValue extends ApplicationIdentity, const EnvironmentsValue extends Readonly<Record<string, ProjectEnvironment>>, const TestsValue extends Tests | undefined = undefined>(input: ProjectInput<ApplicationValue, EnvironmentsValue, TestsValue>): Project<ApplicationValue, EnvironmentsValue, TestsValue>;
+export declare function isProject(input: unknown): input is Project;

package/dist/project/define.js

@@ -0,0 +1,106 @@
+import { isApplication } from '../application/index.js';
+import { isDeployment } from '../deployment/deployment.js';
+import { isTests } from '../testing/index.js';
+const admittedProjects = new WeakSet();
+const ENVIRONMENT_NAME = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/u;
+/** Capture one inert Project definition without loading entrypoints or performing effects. */
+export function defineProject(input) {
+    const value = record(input, 'Project definition');
+    exact(value, ['application', 'environments'], ['entrypoints', 'tests'], invalid);
+    if (!isApplication(input.application))
+        throw new TypeError('Project Application is not admitted.');
+    const environments = record(input.environments, 'Project environments');
+    if (Reflect.ownKeys(environments).some((key) => typeof key !== 'string')) {
+        throw new TypeError('Project Environment names must be strings.');
+    }
+    const names = Object.keys(environments);
+    if (names.length === 0)
+        throw new TypeError('Project must declare at least one Environment.');
+    const captured = Object.create(null);
+    for (const name of names) {
+        if (!ENVIRONMENT_NAME.test(name)) {
+            throw new TypeError(`Project Environment name "${name}" is not normalized.`);
+        }
+        const environment = record(environments[name], `Project Environment ${name}`);
+        exact(environment, ['deployment'], ['installation'], () => invalidEnvironment(name));
+        if (!isDeployment(environment.deployment)) {
+            throw new TypeError(`Project Environment ${name} deployment is not admitted.`);
+        }
+        const installation = environment.installation === undefined
+            ? undefined
+            : admitInstallation(environment.installation, name);
+        environment.deployment.adapter.admit?.(environment.deployment.parameters, {
+            environment: name,
+            ...(installation === undefined ? {} : { installation }),
+        });
+        captured[name] = Object.freeze({
+            deployment: environment.deployment,
+            ...(installation === undefined ? {} : { installation }),
+        });
+    }
+    const entrypoints = input.entrypoints === undefined ? undefined : admitEntrypoints(input.entrypoints);
+    if (input.tests !== undefined && !isTests(input.tests)) {
+        throw new TypeError('Project tests must be created by tests().');
+    }
+    const project = Object.freeze({
+        kind: 'project',
+        application: input.application,
+        environments: Object.freeze(captured),
+        ...(entrypoints === undefined ? {} : { entrypoints }),
+        ...(input.tests === undefined ? {} : { tests: input.tests }),
+    });
+    admittedProjects.add(project);
+    return project;
+}
+export function isProject(input) {
+    return input !== null && typeof input === 'object' && admittedProjects.has(input);
+}
+function admitEntrypoints(input) {
+    const value = record(input, 'Project entrypoints');
+    exact(value, ['runtime'], [], () => {
+        throw new TypeError('Project entrypoints must contain exactly runtime.');
+    });
+    if (typeof input.runtime !== 'string' ||
+        input.runtime.length === 0 ||
+        input.runtime.trim() !== input.runtime ||
+        input.runtime.includes('\0')) {
+        throw new TypeError('Project Runtime entrypoint must be a non-empty stable module coordinate.');
+    }
+    return Object.freeze({ runtime: input.runtime });
+}
+function admitInstallation(input, environment) {
+    const value = record(input, `Project Environment ${environment} installation`);
+    exact(value, ['instance'], ['identity'], () => {
+        throw new TypeError(`Project Environment ${environment} installation may contain only instance and identity.`);
+    });
+    const instance = stableCoordinate(value.instance, 'installation instance');
+    const identity = value.identity === undefined
+        ? undefined
+        : stableCoordinate(value.identity, 'installation identity');
+    return Object.freeze({ instance, ...(identity === undefined ? {} : { identity }) });
+}
+function stableCoordinate(input, label) {
+    if (typeof input !== 'string' || input.length === 0 || input.trim() !== input) {
+        throw new TypeError(`Project ${label} must be a non-empty stable string.`);
+    }
+    return input;
+}
+function record(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError(`${label} must be an object.`);
+    }
+    return input;
+}
+function exact(input, required, optional, fail) {
+    const allowed = new Set([...required, ...optional]);
+    if (required.some((key) => !Object.hasOwn(input, key)) ||
+        Reflect.ownKeys(input).some((key) => !allowed.has(key))) {
+        fail();
+    }
+}
+function invalid() {
+    throw new TypeError('Project definition may contain only application, environments, entrypoints, and tests.');
+}
+function invalidEnvironment(name) {
+    throw new TypeError(`Project Environment ${name} may contain only deployment and installation.`);
+}

package/dist/project/index.d.ts

@@ -0,0 +1,4 @@
+export { admitProjectModule, PROJECT_EXPORT_HINT } from './admit.js';
+export { defineProject, isProject } from './define.js';
+export type { ProjectInput } from './define.js';
+export type { ApplicationOfProject, EnvironmentsOfProject, Project, ProjectEntrypoints, ProjectEnvironment, } from './project.js';

package/dist/project/index.js

@@ -0,0 +1,2 @@
+export { admitProjectModule, PROJECT_EXPORT_HINT } from './admit.js';
+export { defineProject, isProject } from './define.js';

package/dist/project/project.d.ts

@@ -0,0 +1,24 @@
+import type { ApplicationIdentity } from '../application/index.js';
+import type { InstallationTarget } from '../deployment/adapter/index.js';
+import type { Tests } from '../testing/index.js';
+export interface ProjectEntrypoints {
+    readonly runtime: string;
+}
+export interface ProjectEnvironment<DeploymentValue = unknown> {
+    readonly deployment: DeploymentValue;
+    readonly installation?: InstallationTarget;
+}
+/** The complete independently executable software-product definition in astrale.config.ts. */
+export interface Project<ApplicationValue extends ApplicationIdentity = ApplicationIdentity, EnvironmentsValue extends Readonly<Record<string, ProjectEnvironment>> = Readonly<Record<string, ProjectEnvironment>>, TestsValue extends Tests | undefined = undefined> {
+    readonly kind: 'project';
+    readonly application: ApplicationValue;
+    readonly environments: EnvironmentsValue;
+    readonly entrypoints?: ProjectEntrypoints;
+    readonly tests?: TestsValue;
+}
+export type ApplicationOfProject<Value> = Value extends {
+    readonly application: infer ApplicationValue;
+} ? Extract<ApplicationValue, ApplicationIdentity> : never;
+export type EnvironmentsOfProject<Value> = Value extends {
+    readonly environments: infer EnvironmentsValue;
+} ? EnvironmentsValue : never;

package/dist/project/project.js

@@ -0,0 +1 @@
+export {};

package/dist/testing/dataset/admission.d.ts

@@ -0,0 +1,13 @@
+import type { GraphAdmissionContext, GraphData, GraphDiagnostic } from '../../platform/graph/document/index.js';
+import type { Domain } from '../../platform/schema/index.js';
+import { Graph } from '../../platform/graph/document/index.js';
+export declare class DatasetAdmissionError extends TypeError {
+    readonly dataset: string;
+    readonly diagnostics: readonly GraphDiagnostic[];
+    readonly code: 'DATASET_REJECTED';
+    constructor(dataset: string, diagnostics: readonly GraphDiagnostic[]);
+}
+/** Admit Dataset facts through the canonical Kernel Graph admission over the resolved Domain. */
+export declare function admitDatasetGraph(id: string, domain: Domain, data: GraphData): Graph;
+/** Project one resolved Domain closure into the Class knowledge Graph admission requires. */
+export declare function admissionContext(domain: Domain): GraphAdmissionContext;