@astrale-domains/shell 0.1.0-beta.12 → 0.1.0-beta.13

package/dist/workflows/setup/run.js

@@ -0,0 +1,74 @@
+import { issuer } from '@astrale-os/sdk/auth';
+import { ResponseError, TransportError } from '@astrale-os/sdk/client';
+import { InvocationError } from '@astrale-os/sdk/execution';
+import { Path } from '@astrale-os/sdk/graph/path';
+import { repairUser } from '#mutations/user';
+import { observeUserSetup } from '#queries/user';
+import { planUserSetup } from './plan.js';
+import { provisioningRequest, provisioningResult } from './provision.js';
+export async function runSetup(context, role) {
+    const { client, input, step } = context;
+    const identity = Object.freeze({
+        issuer: issuer.accept(input.issuer),
+        subject: input.subject,
+    });
+    const existing = await step.run('resolve-identity', () => client.auth.whois(identity));
+    if (existing === null) {
+        try {
+            const provisioned = await step.run('provision-identity', () => client.auth.provision(provisioningRequest(context.domain, input, role)));
+            return provisioningResult(provisioned);
+        }
+        catch (cause) {
+            if (!recoverableProvisionFailure(cause))
+                throw cause;
+            const recovered = await step.run('recover-provisioned-identity', () => client.auth.whois(identity));
+            if (recovered === null)
+                throw cause;
+            return convergeExisting(context, role, recovered.id, true);
+        }
+    }
+    return convergeExisting(context, role, existing.id, false);
+}
+async function convergeExisting(context, role, userId, changedBeforeObservation) {
+    const observed = await context.step.run('observe-user-setup', () => context.query(observeUserSetup, Path.id(userId).raw));
+    const plan = planUserSetup(context.domain, context.input, role, observed);
+    if (plan.kind === 'conflict')
+        return setupConflict(plan);
+    if (plan.kind === 'unchanged') {
+        return Object.freeze({
+            userId,
+            personalSpaceId: plan.personalSpaceId,
+            changed: changedBeforeObservation,
+        });
+    }
+    const repaired = await context.step.run('repair-user-setup', () => context.mutate(repairUser, plan.repair));
+    if (repaired.ok) {
+        return Object.freeze({ userId, personalSpaceId: repaired.personalSpaceId, changed: true });
+    }
+    if (repaired.outcomeKnown) {
+        throw new InvocationError('CONFLICT', 'Shell User setup conflicted with concurrent graph state.', {
+            reason: { code: repaired.code, details: {} },
+        });
+    }
+    const recovered = await context.step.run('recover-user-repair', () => context.query(observeUserSetup, Path.id(userId).raw));
+    const recoveredPlan = planUserSetup(context.domain, context.input, role, recovered);
+    if (recoveredPlan.kind === 'conflict')
+        return setupConflict(recoveredPlan);
+    if (recoveredPlan.kind === 'unchanged') {
+        return Object.freeze({ userId, personalSpaceId: recoveredPlan.personalSpaceId, changed: true });
+    }
+    throw new InvocationError('BACKEND_UNAVAILABLE', 'Shell User setup outcome remains unknown after exact state observation.', { reason: { code: repaired.code, details: {} } });
+}
+function setupConflict(plan) {
+    throw new InvocationError('CONFLICT', plan.message, {
+        reason: { code: plan.reason, details: {} },
+    });
+}
+function recoverableProvisionFailure(cause) {
+    if (cause instanceof TransportError) {
+        return cause.context.kind === 'invocation' && cause.context.delivery === 'unknown';
+    }
+    return (cause instanceof ResponseError &&
+        (cause.reason?.code === 'PROVISION_CONFLICT' ||
+            cause.reason?.code === 'PROVISION_PRECONDITION_FAILED'));
+}

package/dist/workflows/space/access.d.ts

@@ -0,0 +1,7 @@
+import type { WorkflowContext } from '@astrale-os/sdk/workflow';
+import type { S, Shell } from '#schema';
+export type DesiredSpaceAccess = 'member' | 'admin' | null;
+type SpaceAccessCallable = typeof S.classes.Space.self.methods.addUser | typeof S.classes.Space.self.methods.removeUser;
+type SpaceAccessContext = WorkflowContext<SpaceAccessCallable, Shell>;
+export declare function setUserAccess(context: SpaceAccessContext, desired: DesiredSpaceAccess): Promise<Readonly<Record<never, never>>>;
+export {};

package/dist/workflows/space/access.js

@@ -0,0 +1,41 @@
+import { InvocationError } from '@astrale-os/sdk/execution';
+import { changeSpaceAccess } from '#mutations/space';
+import { observeDirectSpaceAccess } from '#queries/space';
+export async function setUserAccess(context, desired) {
+    const observed = await context.step.run('observe-space-access', () => context.query(observeDirectSpaceAccess, context.input.user));
+    const current = state(observed, context.self);
+    if (current === desired)
+        return Object.freeze({});
+    const result = await context.step.run('change-space-access', () => context.mutate(changeSpaceAccess, {
+        user: context.input.user,
+        space: context.self,
+        addMember: desired === 'member' && current !== 'member',
+        removeMember: current === 'member' && desired !== 'member',
+        addAdmin: desired === 'admin' && current !== 'admin',
+        removeAdmin: current === 'admin' && desired !== 'admin',
+        guards: { member: observed.member.guard, admin: observed.admin.guard },
+    }));
+    if (result.ok)
+        return Object.freeze({});
+    if (result.outcomeKnown)
+        return accessConflict(result.code);
+    const recovered = await context.step.run('recover-space-access', () => context.query(observeDirectSpaceAccess, context.input.user));
+    if (state(recovered, context.self) === desired)
+        return Object.freeze({});
+    throw new InvocationError('BACKEND_UNAVAILABLE', 'Space access outcome remains unknown after exact observation.', { reason: { code: result.code, details: {} } });
+}
+function state(observation, space) {
+    const member = observation.member.spaces.some(({ id }) => id === space);
+    const admin = observation.admin.spaces.some(({ id }) => id === space);
+    if (member && admin) {
+        throw new InvocationError('CONFLICT', 'The User has conflicting direct Space access edges.', {
+            reason: { code: 'SPACE_ACCESS_AMBIGUOUS', details: {} },
+        });
+    }
+    return admin ? 'admin' : member ? 'member' : null;
+}
+function accessConflict(code) {
+    throw new InvocationError('CONFLICT', 'Space access conflicted with concurrent graph state.', {
+        reason: { code, details: {} },
+    });
+}

package/dist/workflows/space/add.d.ts

@@ -0,0 +1,3 @@
+import { type WorkflowDefinition } from '@astrale-os/sdk/workflow';
+import type { ShellSchema } from '#schema';
+export declare const addSpaceUserWorkflow: WorkflowDefinition<typeof ShellSchema, 'Space.addUser'>;

package/dist/workflows/space/add.js

@@ -0,0 +1,3 @@
+import { defineWorkflow } from '@astrale-os/sdk/workflow';
+import { setUserAccess } from './access.js';
+export const addSpaceUserWorkflow = defineWorkflow()('Space.addUser', (context) => setUserAccess(context, context.input.access));

package/dist/workflows/space/default.d.ts

@@ -0,0 +1,3 @@
+import { type WorkflowDefinition } from '@astrale-os/sdk/workflow';
+import type { ShellSchema } from '#schema';
+export declare const setDefaultSpaceWorkflow: WorkflowDefinition<typeof ShellSchema, 'Space.setDefault'>;

package/dist/workflows/space/default.js

@@ -0,0 +1,37 @@
+import { InvocationError } from '@astrale-os/sdk/execution';
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineWorkflow, } from '@astrale-os/sdk/workflow';
+import { changeDefaultSpace } from '#mutations/space';
+import { observeHome } from '#queries/user';
+async function setDefault(context) {
+    const user = context.caller.principal;
+    const observed = await context.step.run('observe-default-space', () => context.query(observeHome, Path.id(user).raw));
+    if (observed.spaces.length > 1) {
+        throw new InvocationError('CONFLICT', 'The Shell User has more than one default Space.', {
+            reason: { code: 'MULTIPLE_DEFAULT_SPACES', details: {} },
+        });
+    }
+    if (observed.spaces[0]?.id === context.self)
+        return Object.freeze({});
+    const result = await context.step.run('change-default-space', () => context.mutate(changeDefaultSpace, {
+        user,
+        ...(observed.spaces[0] === undefined ? {} : { previous: observed.spaces[0].id }),
+        next: context.self,
+        guard: observed.guard,
+    }));
+    if (result.ok)
+        return Object.freeze({});
+    if (result.outcomeKnown)
+        return defaultConflict(result.code);
+    const recovered = await context.step.run('recover-default-space', () => context.query(observeHome, Path.id(user).raw));
+    if (recovered.spaces.length === 1 && recovered.spaces[0]?.id === context.self) {
+        return Object.freeze({});
+    }
+    throw new InvocationError('BACKEND_UNAVAILABLE', 'Default Space outcome remains unknown after exact observation.', { reason: { code: result.code, details: {} } });
+}
+function defaultConflict(code) {
+    throw new InvocationError('CONFLICT', 'Default Space conflicted with concurrent graph state.', {
+        reason: { code, details: {} },
+    });
+}
+export const setDefaultSpaceWorkflow = defineWorkflow()('Space.setDefault', setDefault);

package/dist/workflows/space/index.d.ts

@@ -0,0 +1,4 @@
+export { setUserAccess, type DesiredSpaceAccess } from './access.js';
+export { addSpaceUserWorkflow } from './add.js';
+export { setDefaultSpaceWorkflow } from './default.js';
+export { removeSpaceUserWorkflow } from './remove.js';

package/dist/workflows/space/index.js

@@ -0,0 +1,4 @@
+export { setUserAccess } from './access.js';
+export { addSpaceUserWorkflow } from './add.js';
+export { setDefaultSpaceWorkflow } from './default.js';
+export { removeSpaceUserWorkflow } from './remove.js';

package/dist/workflows/space/remove.d.ts

@@ -0,0 +1,3 @@
+import { type WorkflowDefinition } from '@astrale-os/sdk/workflow';
+import type { ShellSchema } from '#schema';
+export declare const removeSpaceUserWorkflow: WorkflowDefinition<typeof ShellSchema, 'Space.removeUser'>;

package/dist/workflows/space/remove.js

@@ -0,0 +1,3 @@
+import { defineWorkflow } from '@astrale-os/sdk/workflow';
+import { setUserAccess } from './access.js';
+export const removeSpaceUserWorkflow = defineWorkflow()('Space.removeUser', (context) => setUserAccess(context, null));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrale-domains/shell",
-  "version": "0.1.0-beta.12",
-  "description": "Astrale Shell Domain schema contract",
+  "version": "0.1.0-beta.13",
+  "description": "Astrale Shell Domain schema and remote product implementation",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -12,8 +12,8 @@
     "dist"
   ],
   "type": "module",
-  "main": "./dist/schema/index.js",
-  "types": "./dist/schema/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "imports": {
     "#mutations": "./dist/mutations/index.js",
     "#mutations/*": "./dist/mutations/*/index.js",
@@ -26,8 +26,16 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/schema/index.d.ts",
-      "import": "./dist/schema/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./application": {
+      "types": "./dist/entrypoints/application.d.ts",
+      "import": "./dist/entrypoints/application.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/entrypoints/runtime.js"
     },
     "./package.json": "./package.json"
   },
@@ -39,22 +47,30 @@
     "zod": "4.4.3"
   },
   "devDependencies": {
-    "@astrale-os/sdk": "0.5.0-beta.49",
+    "@astrale-os/sdk": "0.5.0-beta.51",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.3",
+    "@types/node": "^22.0.0",
     "typescript": "7.0.2",
     "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "@astrale-os/sdk": ">=0.5.0-beta.32 <1.0.0"
+    "@astrale-os/sdk": ">=0.5.0-beta.51 <1.0.0"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=24 <25 || >=26 <27",
+      "onFail": "error"
+    }
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=22"
   },
   "scripts": {
     "prebuild": "pnpm clean",
-    "build": "tsc --paths null && astrale-domain package",
+    "build": "tsc --project tsconfig.package.json --paths null && node scripts/verify-platform-package.mjs",
     "clean": "rm -rf dist",
-    "typecheck": "tsc --noEmit --paths null",
+    "typecheck": "tsc --noEmit --paths null && tsc --noEmit -p tsconfig.test.json",
     "test": "NODE_PATH=$PWD/node_modules vitest run --config vitest.config.ts",
     "test:file": "NODE_PATH=$PWD/node_modules vitest run --config vitest.config.ts"
   }