slotlock 0.9.0 → 0.10.0

package/self-host.js

@@ -12,15 +12,21 @@ import { createSlotlockStoreAgentBackend, createSlotlockStoreApplicationBackend,
 import { SLOTLOCK_API_KEY_DEFAULT_SCOPES, SLOTLOCK_API_KEY_MAX_LIFETIME_DAYS, SLOTLOCK_API_KEY_SCOPES, createSlotlockApiKeyAuthenticator, createSlotlockApiKeyStore, SLOTLOCK_TEST_TENANT_SUFFIX, slotlockBearerCredential, slotlockLiveTenant, } from './api-keys.js';
 import { SLOTLOCK_SANDBOX_MAX_RACERS, SLOTLOCK_SANDBOX_SCENARIOS, fastForwardSlotlockSandbox, raceSlotlockSandbox, resetSlotlockSandbox, seedSlotlockSandbox, } from './sandbox.js';
 import { createSlotlockDashboard, createSlotlockDashboardResources, createSlotlockAcceptanceRecords, createSlotlockDashboardState, } from './dashboard.js';
-import { SECRET_HINT, SlotlockConfigError, formatSlotlockRate, optional, readAvailability, readDashboardConfig, readDashboardOrganizations, readDashboardUsers, readLimits, readSecret, readServerUrl, readTrustedProxyHeader, readTrustedProxySecret, slotlockKeySubscriptions, } from './config.js';
+import { SECRET_HINT, SlotlockConfigError, formatSlotlockRate, optional, readAvailability, readDashboardConfig, readDashboardOrganizations, readDashboardTeamWorkspaces, readDashboardUsers, readVerifiedDomains, readLimits, readSecret, readServerUrl, readTrustedProxyHeader, readTrustedProxySecret, slotlockKeySubscriptions, } from './config.js';
 import { parseBookingRules } from './booking-rules.js';
 import { slotlockApplicationOperation, slotlockApplicationScope, } from './application-api.js';
 import { SLOTLOCK_ACCOUNT_FIELD, createSlotlockPartnerKey, createSlotlockPartnerKeyAuthenticator, createSlotlockPartnerStore, listSlotlockPartners, putSlotlockPartner, revokeSlotlockPartnerKey, setSlotlockPartnerBilling, setSlotlockPartnerStatus, slotlockPartnerContractJson, } from './partners.js';
 import { closeSlotlockPartnerMonth, slotlockClientLabel, slotlockPreviousMonth } from './partner-billing.js';
 import { createSlotlockDashboardTeams, createSlotlockOrganizationCheck } from './teams.js';
+import { createSlotlockDashboardWorkspaces, createSlotlockWorkspaceCheck } from './workspaces.js';
+import { createSlotlockWorkspaceDomains, runSlotlockDomainChecks } from './workspace-domains.js';
+import { slotlockDomainResolvers } from './domains.js';
+import { createSlotlockSecretBox } from './oidc.js';
+import { createSlotlockInvitationEmailSender } from './invitation-email.js';
 import { SLOTLOCK_DEFAULT_OVERAGE_STOP_PERCENT, reportSlotlockOverage, slotlockMonthOf } from './overage.js';
 import { createSlotlockOtlpExporter, createSlotlockOtlpMetricsExporter, readSlotlockOtlpConfig, } from './otel.js';
-import { readFile } from 'node:fs/promises';
+import { appendFile, mkdir, readdir, readFile } from 'node:fs/promises';
+import { join as joinPath } from 'node:path';
 import { readSlotlockHolidayCalendar } from './holiday-import.js';
 import { SLOTLOCK_DASHBOARD_FUNCTIONS, SLOTLOCK_QUOTA_FUNCTIONS, SLOTLOCK_TENANT_TABLES, SLOTLOCK_USAGE_FUNCTIONS, } from './ddl.js';
 import { maintainSlotlockTenant, startSlotlockMaintenance, withSlotlockMaintenanceLock, } from './maintenance.js';
@@ -32,7 +38,7 @@ import { isSlotlockResourceScope } from './resource-profile.js';
 import { createSlotlockQuotas, noteSlotlockQuotaThreshold, readSlotlockQuotaUse } from './quotas.js';
 import { createSlotlockRequestLimits } from './rate-limit.js';
 import { createSlotlockUsageMeter, recordSlotlockUsage } from './usage.js';
-import { assertSlotlockSchemaCurrent, createSlotlockStore, } from './store.js';
+import { assertSlotlockSchemaCurrent, createSlotlockStore, slotlockAuditEventRecord, } from './store.js';
 import { parseAvailabilityRules } from './weekly-hours.js';
 export { SlotlockConfigError };
 /**
@@ -76,9 +82,18 @@ export const SLOTLOCK_ENVIRONMENT_VARIABLES = Object.freeze([
     'SLOTLOCK_ASSISTANT_PRIVATE_URLS',
     'SLOTLOCK_DASHBOARD_USERS',
     'SLOTLOCK_DASHBOARD_ORGS',
+    'SLOTLOCK_DASHBOARD_TEAM_WORKSPACES',
     'SLOTLOCK_DASHBOARD_NAME',
     'SLOTLOCK_DASHBOARD_TERMS_URL',
     'SLOTLOCK_DASHBOARD_PRIVACY_URL',
+    'SLOTLOCK_INVITATION_EMAIL',
+    'SLOTLOCK_INVITATION_EMAIL_KEY',
+    'SLOTLOCK_INVITATION_EMAIL_FROM',
+    'SLOTLOCK_VERIFIED_DOMAINS',
+    'SLOTLOCK_DNS_RESOLVER',
+    'SLOTLOCK_TEAM_SSO',
+    'SLOTLOCK_SSO_SECRET',
+    'SLOTLOCK_TEAM_SCIM',
     'HOST',
     'PORT',
 ]);
@@ -358,6 +373,11 @@ export function readSlotlockServeConfig(env) {
     const organizations = readDashboardOrganizations(env);
     if (organizations !== undefined)
         config.organizations = organizations;
+    if (readDashboardTeamWorkspaces(env))
+        config.teamWorkspaces = true;
+    const verifiedDomains = readVerifiedDomains(env);
+    if (verifiedDomains !== undefined)
+        config.verifiedDomains = verifiedDomains;
     const allowedUsers = dashboard?.allowedUsers ?? readDashboardUsers(env);
     if (allowedUsers !== undefined)
         config.allowedUsers = allowedUsers;
@@ -610,13 +630,19 @@ function serveMetrics(target, metrics, path, token) {
 }
 /**
  * Whether the dashboard's allowlists let a tenant act, wherever the dashboard runs: a
- * `github-org:<id>` tenant only while SLOTLOCK_DASHBOARD_ORGS lists that organization; a
- * `github:<id>` tenant only while SLOTLOCK_DASHBOARD_USERS is `*` or lists that id; every tenant when
- * SLOTLOCK_DASHBOARD_USERS is not set, and every other tenant.
+ * `github-org:<id>` tenant only while SLOTLOCK_DASHBOARD_ORGS lists that organization; a `team:<id>`
+ * tenant only with SLOTLOCK_DASHBOARD_TEAM_WORKSPACES=on (and, as serve's authenticate asks, while
+ * it exists); a `github:<id>` tenant only while SLOTLOCK_DASHBOARD_USERS is `*` or lists that id;
+ * every tenant when SLOTLOCK_DASHBOARD_USERS is not set, and every other tenant.
  */
 export function slotlockServeAllowsTenant(config, tenantRef) {
     // A test environment (RFC 0003 G9) is let through exactly as its live tenant.
     const live = slotlockLiveTenant(tenantRef);
+    if (live.startsWith('team:'))
+        return config.teamWorkspaces === true;
+    // A person a team's identity provider made has no workspace of their own, so no keys of one.
+    if (live.startsWith('sso:'))
+        return false;
     const orgId = /^github-org:(\d+)$/.exec(live)?.[1];
     // With `enabled`, the database decides, as serve's authenticate asks (createSlotlockOrganizationCheck).
     if (orgId !== undefined)
@@ -821,6 +847,8 @@ export async function startSlotlockServer(config, log) {
             : undefined;
         // Teams on Cloud: an organization's keys work while an owner has it turned on.
         const organizationEnabled = config.organizations === 'enabled' ? createSlotlockOrganizationCheck(sql) : null;
+        // Team workspaces: a team's keys work while it exists.
+        const teamActive = config.teamWorkspaces ? createSlotlockWorkspaceCheck(sql) : null;
         const limits = createSlotlockRequestLimits({
             limits: config.limits,
             ...(config.sharedLimits
@@ -856,6 +884,8 @@ export async function startSlotlockServer(config, log) {
                 const orgId = organizationEnabled ? /^github-org:(\d+)$/.exec(slotlockLiveTenant(principal.tenantRef))?.[1] : undefined;
                 if (orgId !== undefined && !(await organizationEnabled?.(orgId)))
                     return null;
+                if (slotlockLiveTenant(principal.tenantRef).startsWith('team:') && !(await teamActive?.(principal.tenantRef)))
+                    return null;
                 // Slotlock-Account is a partner key's alone (RFC 0003 P3): with any other credential, or one
                 // that could not act for that account, the request is refused rather than run elsewhere.
                 if (request.headers.has(SLOTLOCK_ACCOUNT_FIELD) && principal.onBehalfOf === undefined)
@@ -979,10 +1009,28 @@ export async function startSlotlockServer(config, log) {
                     ? { organizations: config.dashboard.organizations }
                     : {}),
                 ...(config.dashboard.organizations === 'enabled' ? { teams: createSlotlockDashboardTeams(sql) } : {}),
+                ...(config.dashboard.teamWorkspaces ? { teamWorkspaces: true } : {}),
+                ...(config.dashboard.verifiedDomains
+                    ? { domains: { resolvers: slotlockDomainResolvers(config.dashboard.verifiedDomains.resolver) } }
+                    : {}),
+                // Teams' single sign-on: their Owners' URLs fetched never from a private address.
+                ...(config.dashboard.teamSso
+                    ? { sso: { secretBox: createSlotlockSecretBox(config.dashboard.teamSso.secret), fetch: createSlotlockGuardedFetch() } }
+                    : {}),
+                ...(config.dashboard.teamScim ? { scim: true } : {}),
+                ...(config.dashboard.invitationEmail
+                    ? {
+                        invitations: createSlotlockInvitationEmailSender(config.dashboard.invitationEmail, {
+                            ...(config.dashboard.name ? { brandName: config.dashboard.name } : {}),
+                        }),
+                    }
+                    : {}),
                 keys: createSlotlockApiKeyStore(sql),
                 // Holiday calendars by address (RFC 0004 B1), never from a private address.
                 resources: createSlotlockDashboardResources(store, { agentBackend, holidayFetch: createSlotlockGuardedFetch() }),
                 state: createSlotlockDashboardState(sql),
+                // Roles from the database on every request, and "Sign out everywhere" (workspaces.ts).
+                workspaces: createSlotlockDashboardWorkspaces(sql),
                 availability: config.availability,
                 ...(config.usage ? { usage: true } : {}),
                 ...(config.quotas ? { quotas: true } : {}),
@@ -1045,6 +1093,21 @@ export async function startSlotlockServer(config, log) {
             ...(config.usage ? { usage: true } : {}),
             // Holiday calendar subscriptions (RFC 0004 B1), never from a private address.
             holidayFetch: createSlotlockGuardedFetch(),
+            // Team workspaces' verified domains, looked up again each day; each change in the team's audit log.
+            ...(config.verifiedDomains
+                ? {
+                    domainChecks: (() => {
+                        const domains = createSlotlockWorkspaceDomains(sql);
+                        const resolvers = slotlockDomainResolvers(config.verifiedDomains.resolver);
+                        const audit = createSlotlockStore(sql, retention);
+                        return () => runSlotlockDomainChecks({
+                            domains,
+                            resolvers,
+                            record: (tenantRef, event) => audit.withTenant(tenantRef, (tenant) => tenant.recordAuditEvent({ tenantRef, event })).then(() => undefined),
+                        });
+                    })(),
+                }
+                : {}),
             // Counts only, never the tenant.
             onPass: (result) => {
                 metrics?.maintenance(result);
@@ -1261,6 +1324,133 @@ function hoursLine(resource) {
         inherited: resource.inheritedAvailability ?? null,
     })}\n`;
 }
+/**
+ * `tenant export [--out <dir>]` (RFC 0004 D3): everything the tenant keeps, read in one snapshot and
+ * stored nowhere: JSON lines on stdout, or one NDJSON file a table in a new or empty directory.
+ * Prints what it wrote, and records it in the audit log.
+ */
+async function runTenantExport(config, io, out) {
+    if (out !== undefined) {
+        await mkdir(out, { recursive: true });
+        if ((await readdir(out)).length > 0) {
+            io.stderr.write(`slotlock: ${out} is not empty: export into a new or empty directory\n`);
+            return 1;
+        }
+    }
+    const sql = connect(config.databaseUrl, 1);
+    try {
+        const store = createSlotlockStore(sql);
+        const tenantRef = config.tenantRef;
+        const totals = await store.withTenant(tenantRef, async (tenant) => {
+            const read = await tenant.streamTenantExport({
+                tenantRef,
+                onPart: async ({ table, lines }) => {
+                    if (out !== undefined) {
+                        await appendFile(joinPath(out, `${table}.ndjson`), `${lines.join('\n')}\n`, { mode: 0o600 });
+                    }
+                    else {
+                        io.stdout.write(lines.map((line) => `{"table":${JSON.stringify(table)},"row":${line}}\n`).join(''));
+                    }
+                },
+            });
+            await tenant.recordAuditEvent({
+                tenantRef,
+                event: { action: 'export.created', actorType: 'system', actorRef: 'cli', targetType: 'export', metadata: { rows: read.rows } },
+            });
+            return read;
+        });
+        if (out !== undefined)
+            io.stdout.write(`${JSON.stringify({ directory: out, ...totals })}\n`);
+        return 0;
+    }
+    finally {
+        await sql.end({ timeout: 5 });
+    }
+}
+/**
+ * `audit verify|export` (RFC 0004 D2): the tenant's workspace audit log. verify exits 1 when the
+ * chain is broken; export prints every event kept, newest first, as JSON lines.
+ */
+async function runAudit(config, io, subcommand) {
+    const sql = connect(config.databaseUrl, 1);
+    try {
+        const store = createSlotlockStore(sql);
+        const tenantRef = config.tenantRef;
+        if (subcommand === 'audit verify') {
+            const verified = await store.withTenant(tenantRef, (tenant) => tenant.verifyAuditChain({ tenantRef }));
+            io.stdout.write(`${JSON.stringify({ checked: verified.checked, broken_at: verified.brokenAt })}\n`);
+            if (verified.brokenAt === null)
+                return 0;
+            io.stderr.write(`slotlock: the audit log's chain breaks at event ${verified.brokenAt}: it was changed outside Slotlock\n`);
+            return 1;
+        }
+        let before;
+        for (;;) {
+            const page = await store.withTenant(tenantRef, (tenant) => tenant.listAuditEvents({ tenantRef, limit: 200, ...(before ? { beforeId: before } : {}) }));
+            for (const event of page)
+                io.stdout.write(`${JSON.stringify(slotlockAuditEventRecord(event))}\n`);
+            const last = page.at(-1);
+            if (page.length < 200 || !last)
+                return 0;
+            before = last.id;
+        }
+    }
+    finally {
+        await sql.end({ timeout: 5 });
+    }
+}
+/**
+ * `subject export|erase` (RFC 0004 D3): what the tenant keeps about one person, and taking them out
+ * of it. The erasure is recorded in the audit log without the person.
+ */
+async function runSubject(config, io, subcommand, subject) {
+    const sql = connect(config.databaseUrl, 1);
+    try {
+        const store = createSlotlockStore(sql);
+        const tenantRef = config.tenantRef;
+        try {
+            if (subcommand === 'subject export') {
+                const exported = await store.withTenant(tenantRef, (tenant) => tenant.exportSubject({ tenantRef, subject, limit: 10_000 }));
+                for (const [table, rows] of Object.entries(exported.records)) {
+                    for (const row of rows)
+                        io.stdout.write(`${JSON.stringify({ table, row })}\n`);
+                }
+                if (exported.truncated)
+                    io.stderr.write('slotlock: a table had more than 10,000 rows; the first 10,000 are listed\n');
+                return 0;
+            }
+            const { erased } = await store.withTenant(tenantRef, async (tenant) => {
+                const result = await tenant.eraseSubject({ tenantRef, subject });
+                await tenant.recordAuditEvent({
+                    tenantRef,
+                    event: {
+                        action: 'subject.erased',
+                        actorType: 'system',
+                        actorRef: 'cli',
+                        targetType: 'subject',
+                        metadata: {
+                            by: Object.keys(subject)[0],
+                            ...Object.fromEntries(Object.entries(result.erased).filter(([, rows]) => rows > 0)),
+                        },
+                    },
+                });
+                return result;
+            }, { isolation: 'read committed' });
+            io.stdout.write(`${JSON.stringify({ erased })}\n`);
+            return 0;
+        }
+        catch (error) {
+            if (error?.code === 'invalid_subject') {
+                io.stderr.write('slotlock: give an email address, or a holder, contact or booking reference of 1-500 bytes\n');
+                return 2;
+            }
+            throw error;
+        }
+    }
+    finally {
+        await sql.end({ timeout: 5 });
+    }
+}
 /**
  * `closures list|add|delete|import` (RFC 0004 B1): the tenant's closures and special days. Exit 0, 1
  * when a name, id or file is not found or refused, as JSON lines on stdout.
@@ -1939,6 +2129,8 @@ async function maintainTenant(config, caps) {
             // Every tenant's expired assistant conversations, a tenant only the dashboard serves
             // included. Counted nowhere: the counts above are this tenant's.
             await store.sweepAssistantConversations();
+            // And finished team invitations, with the addresses they were sent to, and ended sessions.
+            await store.sweepDashboardRecords();
             return sum;
         });
         return total ?? null;
@@ -2095,10 +2287,24 @@ Commands:
                            no new secret (as SLOTLOCK_MIGRATE_DATABASE_URL's role when set:
                            only the schema owner suspends)
   tenant unsuspend         Lift the tenant's suspension (as the schema owner, likewise)
+  tenant export [--out <dir>]
+                           Print everything the tenant keeps, read at one moment, one JSON line a
+                           row ({"table": ..., "row": ...}); with --out, one <table>.ndjson file a
+                           table in that directory (new or empty). Secrets stay out
   tenant erase --confirm <tenant>
                            Delete everything the tenant has, its API keys included, for good;
                            --confirm repeats SLOTLOCK_TENANT; refused while its hosted plan is
                            paid for (cancel the subscription first)
+  audit verify             Check the tenant's audit log chain: prints how many events held and
+                           the first that does not (exit 1 when one does not)
+  audit export             Print the tenant's audit log, newest first, one JSON object per line
+  subject export (--email <address> | --holder <ref> | --contact <ref> | --reference <ref>)
+                           Print what the tenant keeps about one person, one JSON line per row:
+                           {"table": ..., "row": ...}, up to 10,000 rows a table
+  subject erase (--email <address> | --holder <ref> | --contact <ref> | --reference <ref>)
+                           Take one person out of the tenant's data: their contacts, attendee
+                           and waitlist entries go; their references become an erased name;
+                           bookings stay as time taken. Prints what it changed, by table
   plan status              Print the deployment's default plan and the tenant's own (hosted)
   plan default (free | developer | none) [--from <date>]
                            Put every tenant without a plan of its own on this one from --from
@@ -2202,10 +2408,26 @@ Environment:
   SLOTLOCK_DASHBOARD_ORGS        comma-separated GitHub organization ids: each is one shared tenant;
                                  or enabled: each person's own tenant, plus the organizations an
                                  owner turns on from the dashboard's Teams page
+  SLOTLOCK_DASHBOARD_TEAM_WORKSPACES on: anyone signed in creates team workspaces and invites
+                                 people to them by email, each with a role (default off; not
+                                 with organization ids)
   SLOTLOCK_DASHBOARD_NAME        What the dashboard calls this deployment (default Slotlock)
   SLOTLOCK_DASHBOARD_TERMS_URL   https URL of the terms people accept by signing in, linked on the
                                  sign-in page (none named without it)
   SLOTLOCK_DASHBOARD_PRIVACY_URL https URL of the privacy notice the sign-in page links
+  SLOTLOCK_INVITATION_EMAIL      resend or postmark: send team invitations by email (with team
+                                 workspaces; without it, the person inviting sends the link)
+  SLOTLOCK_INVITATION_EMAIL_KEY  Resend's API key, or Postmark's server token
+  SLOTLOCK_INVITATION_EMAIL_FROM The sender the provider verified: team@example.com or Name <...>
+  SLOTLOCK_VERIFIED_DOMAINS      on or off (default): team Owners verify their domain with a DNS
+                                 record, and people at it may ask to join (with team workspaces)
+  SLOTLOCK_DNS_RESOLVER          doh (default: Cloudflare, checked by Google) or system: how a
+                                 verified domain's record is looked up each day
+  SLOTLOCK_TEAM_SSO              on or off (default): each team signs in through its own identity
+                                 provider over OpenID Connect (with verified domains)
+  SLOTLOCK_SSO_SECRET            32+ characters: seals each team's client secret (with team SSO)
+  SLOTLOCK_TEAM_SCIM             on or off (default): each team's identity provider provisions its
+                                 people over SCIM 2.0 at /dashboard/scim/v2 (with verified domains)
   HOST                           Listen address (default 127.0.0.1)
   PORT                           Listen port (default 8080)
 
@@ -2252,7 +2474,9 @@ export async function runSlotlockCli(argv, io) {
         command === 'partner' ||
         command === 'overage' ||
         command === 'billing' ||
-        command === 'sandbox'
+        command === 'sandbox' ||
+        command === 'audit' ||
+        command === 'subject'
         ? `${command} ${operands[0] ?? ''}`.trim()
         : command;
     const expectedOperands = {
@@ -2267,6 +2491,7 @@ export async function runSlotlockCli(argv, io) {
         'resource restore': 2,
         'resource delete': 2,
         'tenant status': 1,
+        'tenant export': 1,
         'tenant suspend': 1,
         'tenant unsuspend': 1,
         'tenant erase': 1,
@@ -2301,6 +2526,10 @@ export async function runSlotlockCli(argv, io) {
         'partner close': 2,
         'overage report': 1,
         'billing daily': 1,
+        'audit verify': 1,
+        'audit export': 1,
+        'subject export': 1,
+        'subject erase': 1,
     };
     // closures add takes a last day or not.
     const expected = subcommand === 'closures add' && operands.length === 3 ? 3 : expectedOperands[subcommand];
@@ -2357,6 +2586,15 @@ export async function runSlotlockCli(argv, io) {
         if (named !== 'none')
             planDefault = { plan: named, appliesFrom };
     }
+    const subjectOptions = ['email', 'holder', 'contact', 'reference'].filter((option) => values[option] !== undefined);
+    if (subjectOptions.length > 0 && !subcommand.startsWith('subject ')) {
+        return usage('--email, --holder, --contact and --reference apply only to subject export and subject erase');
+    }
+    if (subcommand.startsWith('subject ') && subjectOptions.length !== 1) {
+        return usage(`${subcommand} needs exactly one of --email, --holder, --contact or --reference`);
+    }
+    if (values.out !== undefined && subcommand !== 'tenant export')
+        return usage('--out applies only to tenant export');
     if (subcommand === 'tenant erase' && values.confirm === undefined) {
         return usage('tenant erase needs --confirm <tenant>, the tenant it erases (SLOTLOCK_TENANT)');
     }
@@ -2588,6 +2826,8 @@ export async function runSlotlockCli(argv, io) {
                 }
                 return 0;
             }
+            case 'tenant export':
+                return runTenantExport(readSlotlockDatabaseConfig(io.env), io, values.out);
             case 'tenant status':
             case 'tenant suspend':
             case 'tenant unsuspend':
@@ -2679,6 +2919,16 @@ export async function runSlotlockCli(argv, io) {
                 }
                 return 0;
             }
+            case 'audit verify':
+            case 'audit export':
+                return runAudit(readSlotlockDatabaseConfig(io.env), io, subcommand);
+            case 'subject export':
+            case 'subject erase': {
+                const option = subjectOptions[0];
+                return runSubject(readSlotlockDatabaseConfig(io.env), io, subcommand, {
+                    [option]: values[option],
+                });
+            }
             case 'closures list':
             case 'closures add':
             case 'closures delete':
@@ -2797,6 +3047,11 @@ function parseCliArguments(argv) {
             open: { type: 'string' },
             reason: { type: 'string' },
             confirm: { type: 'string' },
+            out: { type: 'string' },
+            email: { type: 'string' },
+            holder: { type: 'string' },
+            contact: { type: 'string' },
+            reference: { type: 'string' },
             from: { type: 'string' },
             help: { type: 'boolean', short: 'h' },
             version: { type: 'boolean', short: 'v' },

package/slotlock.manifest.json

@@ -3,7 +3,7 @@
   "schemaVersion": "1.0",
   "name": "Slotlock",
   "package": "slotlock",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Resource-first, deterministic calendar and availability engine for AI agents.",
   "intervalSemantics": {
     "boundary": "[)",