@elaraai/e3-types 0.0.2-beta.12 → 0.0.2-beta.14

package/dist/src/index.d.ts

@@ -26,4 +26,5 @@ export { StructureType, type Structure, PathSegmentType, type PathSegment, TreeP
 export { PackageDataType, type PackageData, PackageObjectType, type PackageObject, PackageDatasetsType, type PackageDatasets, } from './package.js';
 export { WorkspaceStateType, type WorkspaceState, } from './workspace.js';
 export { ExecutionStatusType, type ExecutionStatus, } from './execution.js';
+export { LockOperationType, type LockOperation, ProcessHolderType, type ProcessHolder, LockStateType, type LockState, } from './lock.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EACL,WAAW,EACX,KAAK,OAAO,EACZ,aAAa,EACb,OAAO,EACP,YAAY,GACb,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,cAAc,EACd,KAAK,UAAU,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,aAAa,EACb,KAAK,SAAS,EACd,eAAe,EACf,KAAK,WAAW,EAChB,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAEjB,iBAAiB,EACjB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,eAAe,EACf,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,aAAa,EAElB,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EACL,WAAW,EACX,KAAK,OAAO,EACZ,aAAa,EACb,OAAO,EACP,YAAY,GACb,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,cAAc,EACd,KAAK,UAAU,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,aAAa,EACb,KAAK,SAAS,EACd,eAAe,EACf,KAAK,WAAW,EAChB,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAEjB,iBAAiB,EACjB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,eAAe,EACf,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,aAAa,EAElB,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,iBAAiB,EACjB,KAAK,aAAa,EAClB,iBAAiB,EACjB,KAAK,aAAa,EAClB,aAAa,EACb,KAAK,SAAS,GACf,MAAM,WAAW,CAAC"}

package/dist/src/index.js

@@ -36,4 +36,6 @@ PackageDatasetsType, } from './package.js';
 export { WorkspaceStateType, } from './workspace.js';
 // Execution status
 export { ExecutionStatusType, } from './execution.js';
+// Lock state
+export { LockOperationType, ProcessHolderType, LockStateType, } from './lock.js';
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH,4BAA4B;AAC5B,OAAO,EACL,WAAW,EAEX,aAAa,EACb,OAAO,EACP,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,mBAAmB;AACnB,OAAO,EACL,cAAc,GAEf,MAAM,WAAW,CAAC;AAEnB,2BAA2B;AAC3B,OAAO,EACL,aAAa,EAEb,eAAe,EAEf,YAAY,EAKZ,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,iBAAiB;AACjB,0BAA0B;AAC1B,iBAAiB,GAElB,MAAM,gBAAgB,CAAC;AAExB,kBAAkB;AAClB,OAAO,EACL,eAAe,EAEf,iBAAiB;AAEjB,0BAA0B;AAC1B,mBAAmB,GAEpB,MAAM,cAAc,CAAC;AAEtB,kBAAkB;AAClB,OAAO,EACL,kBAAkB,GAEnB,MAAM,gBAAgB,CAAC;AAExB,mBAAmB;AACnB,OAAO,EACL,mBAAmB,GAEpB,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH,4BAA4B;AAC5B,OAAO,EACL,WAAW,EAEX,aAAa,EACb,OAAO,EACP,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,mBAAmB;AACnB,OAAO,EACL,cAAc,GAEf,MAAM,WAAW,CAAC;AAEnB,2BAA2B;AAC3B,OAAO,EACL,aAAa,EAEb,eAAe,EAEf,YAAY,EAKZ,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,iBAAiB;AACjB,0BAA0B;AAC1B,iBAAiB,GAElB,MAAM,gBAAgB,CAAC;AAExB,kBAAkB;AAClB,OAAO,EACL,eAAe,EAEf,iBAAiB;AAEjB,0BAA0B;AAC1B,mBAAmB,GAEpB,MAAM,cAAc,CAAC;AAEtB,kBAAkB;AAClB,OAAO,EACL,kBAAkB,GAEnB,MAAM,gBAAgB,CAAC;AAExB,mBAAmB;AACnB,OAAO,EACL,mBAAmB,GAEpB,MAAM,gBAAgB,CAAC;AAExB,aAAa;AACb,OAAO,EACL,iBAAiB,EAEjB,iBAAiB,EAEjB,aAAa,GAEd,MAAM,WAAW,CAAC"}

package/dist/src/lock.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Lock state type definitions.
+ *
+ * A lock provides exclusive access to a workspace. The state tracks:
+ * - What operation acquired the lock (dataflow, deployment, etc.)
+ * - Who holds the lock (East text-encoded string)
+ * - When it was acquired
+ * - Optional expiry (for cloud TTL-based locks)
+ *
+ * Lock file location: workspaces/<name>.lock
+ *
+ * The holder field is an East text-encoded string, allowing different backends
+ * to encode their own holder identification. Common patterns:
+ * - Local: `.process (pid=1234, bootId="abc-123", startTime=98765, command="e3 start")`
+ * - Cloud: `.lambda (requestId="req-123", functionName="e3-api")`
+ */
+import { VariantType, StructType, StringType, IntegerType, DateTimeType, OptionType, NullType, ValueTypeOf } from '@elaraai/east';
+/**
+ * Lock operation - what acquired the lock.
+ */
+export declare const LockOperationType: VariantType<{
+    /** Running a dataflow */
+    readonly dataflow: NullType;
+    /** Deploying a package to the workspace */
+    readonly deployment: NullType;
+    /** Removing the workspace */
+    readonly removal: NullType;
+    /** Writing to a dataset */
+    readonly dataset_write: NullType;
+}>;
+export type LockOperation = ValueTypeOf<typeof LockOperationType>;
+/**
+ * Process holder schema - for local filesystem backends.
+ * Used to encode/decode the holder string.
+ */
+export declare const ProcessHolderType: StructType<{
+    /** Process ID */
+    readonly pid: IntegerType;
+    /** System boot ID (from /proc/sys/kernel/random/boot_id) */
+    readonly bootId: StringType;
+    /** Process start time in jiffies since boot */
+    readonly startTime: IntegerType;
+    /** Command that acquired the lock (for debugging) */
+    readonly command: StringType;
+}>;
+export type ProcessHolder = ValueTypeOf<typeof ProcessHolderType>;
+/**
+ * Lock state stored in workspaces/<name>.lock
+ *
+ * Represents an advisory lock on a workspace. The actual locking mechanism
+ * is platform-specific (flock on Linux, DynamoDB conditional writes in cloud),
+ * but the lock content follows this schema.
+ *
+ * The holder field is an East text-encoded string representing a variant value.
+ * Use `printFor`/`parseInferred` from @elaraai/east to encode/decode.
+ */
+export declare const LockStateType: StructType<{
+    /** What operation acquired the lock */
+    readonly operation: VariantType<{
+        /** Running a dataflow */
+        readonly dataflow: NullType;
+        /** Deploying a package to the workspace */
+        readonly deployment: NullType;
+        /** Removing the workspace */
+        readonly removal: NullType;
+        /** Writing to a dataset */
+        readonly dataset_write: NullType;
+    }>;
+    /** Who holds the lock - East text-encoded variant (e.g., `.process (...)`) */
+    readonly holder: StringType;
+    /** When the lock was acquired */
+    readonly acquiredAt: DateTimeType;
+    /** When the lock expires (for cloud TTL-based locks) */
+    readonly expiresAt: OptionType<DateTimeType>;
+}>;
+export type LockState = ValueTypeOf<typeof LockStateType>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/src/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,WAAW,EACZ,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,yBAAyB;;IAEzB,2CAA2C;;IAE3C,6BAA6B;;IAE7B,2BAA2B;;EAE3B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,iBAAiB;;IAEjB,4DAA4D;;IAE5D,+CAA+C;;IAE/C,qDAAqD;;EAErD,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa;IACxB,uCAAuC;;QAxCvC,yBAAyB;;QAEzB,2CAA2C;;QAE3C,6BAA6B;;QAE7B,2BAA2B;;;IAoC3B,8EAA8E;;IAE9E,iCAAiC;;IAEjC,wDAAwD;;EAExD,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/src/lock.js

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Lock state type definitions.
+ *
+ * A lock provides exclusive access to a workspace. The state tracks:
+ * - What operation acquired the lock (dataflow, deployment, etc.)
+ * - Who holds the lock (East text-encoded string)
+ * - When it was acquired
+ * - Optional expiry (for cloud TTL-based locks)
+ *
+ * Lock file location: workspaces/<name>.lock
+ *
+ * The holder field is an East text-encoded string, allowing different backends
+ * to encode their own holder identification. Common patterns:
+ * - Local: `.process (pid=1234, bootId="abc-123", startTime=98765, command="e3 start")`
+ * - Cloud: `.lambda (requestId="req-123", functionName="e3-api")`
+ */
+import { VariantType, StructType, StringType, IntegerType, DateTimeType, OptionType, NullType, } from '@elaraai/east';
+/**
+ * Lock operation - what acquired the lock.
+ */
+export const LockOperationType = VariantType({
+    /** Running a dataflow */
+    dataflow: NullType,
+    /** Deploying a package to the workspace */
+    deployment: NullType,
+    /** Removing the workspace */
+    removal: NullType,
+    /** Writing to a dataset */
+    dataset_write: NullType,
+});
+/**
+ * Process holder schema - for local filesystem backends.
+ * Used to encode/decode the holder string.
+ */
+export const ProcessHolderType = StructType({
+    /** Process ID */
+    pid: IntegerType,
+    /** System boot ID (from /proc/sys/kernel/random/boot_id) */
+    bootId: StringType,
+    /** Process start time in jiffies since boot */
+    startTime: IntegerType,
+    /** Command that acquired the lock (for debugging) */
+    command: StringType,
+});
+/**
+ * Lock state stored in workspaces/<name>.lock
+ *
+ * Represents an advisory lock on a workspace. The actual locking mechanism
+ * is platform-specific (flock on Linux, DynamoDB conditional writes in cloud),
+ * but the lock content follows this schema.
+ *
+ * The holder field is an East text-encoded string representing a variant value.
+ * Use `printFor`/`parseInferred` from @elaraai/east to encode/decode.
+ */
+export const LockStateType = StructType({
+    /** What operation acquired the lock */
+    operation: LockOperationType,
+    /** Who holds the lock - East text-encoded variant (e.g., `.process (...)`) */
+    holder: StringType,
+    /** When the lock was acquired */
+    acquiredAt: DateTimeType,
+    /** When the lock expires (for cloud TTL-based locks) */
+    expiresAt: OptionType(DateTimeType),
+});
+//# sourceMappingURL=lock.js.map

package/dist/src/lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../src/lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,QAAQ,GAET,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC;IAC3C,yBAAyB;IACzB,QAAQ,EAAE,QAAQ;IAClB,2CAA2C;IAC3C,UAAU,EAAE,QAAQ;IACpB,6BAA6B;IAC7B,OAAO,EAAE,QAAQ;IACjB,2BAA2B;IAC3B,aAAa,EAAE,QAAQ;CACxB,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;IAC1C,iBAAiB;IACjB,GAAG,EAAE,WAAW;IAChB,4DAA4D;IAC5D,MAAM,EAAE,UAAU;IAClB,+CAA+C;IAC/C,SAAS,EAAE,WAAW;IACtB,qDAAqD;IACrD,OAAO,EAAE,UAAU;CACpB,CAAC,CAAC;AAIH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;IACtC,uCAAuC;IACvC,SAAS,EAAE,iBAAiB;IAC5B,8EAA8E;IAC9E,MAAM,EAAE,UAAU;IAClB,iCAAiC;IACjC,UAAU,EAAE,YAAY;IACxB,wDAAwD;IACxD,SAAS,EAAE,UAAU,CAAC,YAAY,CAAC;CACpC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elaraai/e3-types",
-  "version": "0.0.2-beta.12",
+  "version": "0.0.2-beta.14",
   "description": "Shared type definitions for e3 (East Execution Engine)",
   "type": "module",
   "main": "dist/src/index.js",

package/src/index.ts

@@ -81,3 +81,13 @@ export {
   ExecutionStatusType,
   type ExecutionStatus,
 } from './execution.js';
+
+// Lock state
+export {
+  LockOperationType,
+  type LockOperation,
+  ProcessHolderType,
+  type ProcessHolder,
+  LockStateType,
+  type LockState,
+} from './lock.js';

package/src/lock.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+
+/**
+ * Lock state type definitions.
+ *
+ * A lock provides exclusive access to a workspace. The state tracks:
+ * - What operation acquired the lock (dataflow, deployment, etc.)
+ * - Who holds the lock (East text-encoded string)
+ * - When it was acquired
+ * - Optional expiry (for cloud TTL-based locks)
+ *
+ * Lock file location: workspaces/<name>.lock
+ *
+ * The holder field is an East text-encoded string, allowing different backends
+ * to encode their own holder identification. Common patterns:
+ * - Local: `.process (pid=1234, bootId="abc-123", startTime=98765, command="e3 start")`
+ * - Cloud: `.lambda (requestId="req-123", functionName="e3-api")`
+ */
+
+import {
+  VariantType,
+  StructType,
+  StringType,
+  IntegerType,
+  DateTimeType,
+  OptionType,
+  NullType,
+  ValueTypeOf,
+} from '@elaraai/east';
+
+/**
+ * Lock operation - what acquired the lock.
+ */
+export const LockOperationType = VariantType({
+  /** Running a dataflow */
+  dataflow: NullType,
+  /** Deploying a package to the workspace */
+  deployment: NullType,
+  /** Removing the workspace */
+  removal: NullType,
+  /** Writing to a dataset */
+  dataset_write: NullType,
+});
+
+export type LockOperation = ValueTypeOf<typeof LockOperationType>;
+
+/**
+ * Process holder schema - for local filesystem backends.
+ * Used to encode/decode the holder string.
+ */
+export const ProcessHolderType = StructType({
+  /** Process ID */
+  pid: IntegerType,
+  /** System boot ID (from /proc/sys/kernel/random/boot_id) */
+  bootId: StringType,
+  /** Process start time in jiffies since boot */
+  startTime: IntegerType,
+  /** Command that acquired the lock (for debugging) */
+  command: StringType,
+});
+
+export type ProcessHolder = ValueTypeOf<typeof ProcessHolderType>;
+
+/**
+ * Lock state stored in workspaces/<name>.lock
+ *
+ * Represents an advisory lock on a workspace. The actual locking mechanism
+ * is platform-specific (flock on Linux, DynamoDB conditional writes in cloud),
+ * but the lock content follows this schema.
+ *
+ * The holder field is an East text-encoded string representing a variant value.
+ * Use `printFor`/`parseInferred` from @elaraai/east to encode/decode.
+ */
+export const LockStateType = StructType({
+  /** What operation acquired the lock */
+  operation: LockOperationType,
+  /** Who holds the lock - East text-encoded variant (e.g., `.process (...)`) */
+  holder: StringType,
+  /** When the lock was acquired */
+  acquiredAt: DateTimeType,
+  /** When the lock expires (for cloud TTL-based locks) */
+  expiresAt: OptionType(DateTimeType),
+});
+
+export type LockState = ValueTypeOf<typeof LockStateType>;