@loop-engine/core 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,2 +1,386 @@
-export * from "./types";
-//# sourceMappingURL=index.d.ts.map
+import { z } from 'zod';
+
+declare const LoopIdSchema: z.ZodBranded<z.ZodString, "LoopId">;
+type LoopId = z.infer<typeof LoopIdSchema>;
+declare const AggregateIdSchema: z.ZodBranded<z.ZodString, "AggregateId">;
+type AggregateId = z.infer<typeof AggregateIdSchema>;
+declare const ActorIdSchema: z.ZodBranded<z.ZodString, "ActorId">;
+type ActorId = z.infer<typeof ActorIdSchema>;
+declare const SignalIdSchema: z.ZodBranded<z.ZodString, "SignalId">;
+type SignalId = z.infer<typeof SignalIdSchema>;
+declare const GuardIdSchema: z.ZodBranded<z.ZodString, "GuardId">;
+type GuardId = z.infer<typeof GuardIdSchema>;
+declare const StateIdSchema: z.ZodBranded<z.ZodString, "StateId">;
+type StateId = z.infer<typeof StateIdSchema>;
+declare const TransitionIdSchema: z.ZodBranded<z.ZodString, "TransitionId">;
+type TransitionId = z.infer<typeof TransitionIdSchema>;
+declare const LoopStatusSchema: z.ZodEnum<["pending", "active", "completed", "failed", "cancelled", "suspended"]>;
+type LoopStatus = z.infer<typeof LoopStatusSchema>;
+declare const ActorTypeSchema: z.ZodEnum<["human", "automation", "ai-agent"]>;
+type ActorType = z.infer<typeof ActorTypeSchema>;
+declare const ActorRefSchema: z.ZodObject<{
+    id: z.ZodBranded<z.ZodString, "ActorId">;
+    type: z.ZodEnum<["human", "automation", "ai-agent"]>;
+    displayName: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "human" | "automation" | "ai-agent";
+    id: string & z.BRAND<"ActorId">;
+    displayName?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    type: "human" | "automation" | "ai-agent";
+    id: string;
+    displayName?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type ActorRef = z.infer<typeof ActorRefSchema>;
+declare const GuardSeveritySchema: z.ZodEnum<["hard", "soft"]>;
+type GuardSeverity = z.infer<typeof GuardSeveritySchema>;
+declare const GuardSpecSchema: z.ZodObject<{
+    guardId: z.ZodBranded<z.ZodString, "GuardId">;
+    description: z.ZodString;
+    severity: z.ZodEnum<["hard", "soft"]>;
+    evaluatedBy: z.ZodEnum<["runtime", "module", "external"]>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    guardId: string & z.BRAND<"GuardId">;
+    description: string;
+    severity: "hard" | "soft";
+    evaluatedBy: "runtime" | "module" | "external";
+    parameters?: Record<string, unknown> | undefined;
+}, {
+    guardId: string;
+    description: string;
+    severity: "hard" | "soft";
+    evaluatedBy: "runtime" | "module" | "external";
+    parameters?: Record<string, unknown> | undefined;
+}>;
+type GuardSpec = z.infer<typeof GuardSpecSchema>;
+declare const TransitionSpecSchema: z.ZodObject<{
+    transitionId: z.ZodBranded<z.ZodString, "TransitionId">;
+    from: z.ZodBranded<z.ZodString, "StateId">;
+    to: z.ZodBranded<z.ZodString, "StateId">;
+    signal: z.ZodBranded<z.ZodString, "SignalId">;
+    allowedActors: z.ZodArray<z.ZodEnum<["human", "automation", "ai-agent"]>, "many">;
+    guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        guardId: z.ZodBranded<z.ZodString, "GuardId">;
+        description: z.ZodString;
+        severity: z.ZodEnum<["hard", "soft"]>;
+        evaluatedBy: z.ZodEnum<["runtime", "module", "external"]>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        guardId: string & z.BRAND<"GuardId">;
+        description: string;
+        severity: "hard" | "soft";
+        evaluatedBy: "runtime" | "module" | "external";
+        parameters?: Record<string, unknown> | undefined;
+    }, {
+        guardId: string;
+        description: string;
+        severity: "hard" | "soft";
+        evaluatedBy: "runtime" | "module" | "external";
+        parameters?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    transitionId: string & z.BRAND<"TransitionId">;
+    from: string & z.BRAND<"StateId">;
+    to: string & z.BRAND<"StateId">;
+    signal: string & z.BRAND<"SignalId">;
+    allowedActors: ("human" | "automation" | "ai-agent")[];
+    description?: string | undefined;
+    guards?: {
+        guardId: string & z.BRAND<"GuardId">;
+        description: string;
+        severity: "hard" | "soft";
+        evaluatedBy: "runtime" | "module" | "external";
+        parameters?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}, {
+    transitionId: string;
+    from: string;
+    to: string;
+    signal: string;
+    allowedActors: ("human" | "automation" | "ai-agent")[];
+    description?: string | undefined;
+    guards?: {
+        guardId: string;
+        description: string;
+        severity: "hard" | "soft";
+        evaluatedBy: "runtime" | "module" | "external";
+        parameters?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}>;
+type TransitionSpec = z.infer<typeof TransitionSpecSchema>;
+declare const StateSpecSchema: z.ZodObject<{
+    stateId: z.ZodBranded<z.ZodString, "StateId">;
+    label: z.ZodString;
+    terminal: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    stateId: string & z.BRAND<"StateId">;
+    label: string;
+    description?: string | undefined;
+    terminal?: boolean | undefined;
+}, {
+    stateId: string;
+    label: string;
+    description?: string | undefined;
+    terminal?: boolean | undefined;
+}>;
+type StateSpec = z.infer<typeof StateSpecSchema>;
+declare const BusinessMetricSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    unit: z.ZodString;
+    improvableByAI: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    unit: string;
+    improvableByAI?: boolean | undefined;
+}, {
+    id: string;
+    label: string;
+    unit: string;
+    improvableByAI?: boolean | undefined;
+}>;
+type BusinessMetric = z.infer<typeof BusinessMetricSchema>;
+declare const OutcomeSpecSchema: z.ZodObject<{
+    description: z.ZodString;
+    valueUnit: z.ZodString;
+    businessMetrics: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        unit: z.ZodString;
+        improvableByAI: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        unit: string;
+        improvableByAI?: boolean | undefined;
+    }, {
+        id: string;
+        label: string;
+        unit: string;
+        improvableByAI?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    valueUnit: string;
+    businessMetrics: {
+        id: string;
+        label: string;
+        unit: string;
+        improvableByAI?: boolean | undefined;
+    }[];
+}, {
+    description: string;
+    valueUnit: string;
+    businessMetrics: {
+        id: string;
+        label: string;
+        unit: string;
+        improvableByAI?: boolean | undefined;
+    }[];
+}>;
+type OutcomeSpec = z.infer<typeof OutcomeSpecSchema>;
+declare const LoopDefinitionSchema: z.ZodObject<{
+    loopId: z.ZodBranded<z.ZodString, "LoopId">;
+    version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    states: z.ZodArray<z.ZodObject<{
+        stateId: z.ZodBranded<z.ZodString, "StateId">;
+        label: z.ZodString;
+        terminal: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        stateId: string & z.BRAND<"StateId">;
+        label: string;
+        description?: string | undefined;
+        terminal?: boolean | undefined;
+    }, {
+        stateId: string;
+        label: string;
+        description?: string | undefined;
+        terminal?: boolean | undefined;
+    }>, "many">;
+    initialState: z.ZodBranded<z.ZodString, "StateId">;
+    transitions: z.ZodArray<z.ZodObject<{
+        transitionId: z.ZodBranded<z.ZodString, "TransitionId">;
+        from: z.ZodBranded<z.ZodString, "StateId">;
+        to: z.ZodBranded<z.ZodString, "StateId">;
+        signal: z.ZodBranded<z.ZodString, "SignalId">;
+        allowedActors: z.ZodArray<z.ZodEnum<["human", "automation", "ai-agent"]>, "many">;
+        guards: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            guardId: z.ZodBranded<z.ZodString, "GuardId">;
+            description: z.ZodString;
+            severity: z.ZodEnum<["hard", "soft"]>;
+            evaluatedBy: z.ZodEnum<["runtime", "module", "external"]>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            guardId: string & z.BRAND<"GuardId">;
+            description: string;
+            severity: "hard" | "soft";
+            evaluatedBy: "runtime" | "module" | "external";
+            parameters?: Record<string, unknown> | undefined;
+        }, {
+            guardId: string;
+            description: string;
+            severity: "hard" | "soft";
+            evaluatedBy: "runtime" | "module" | "external";
+            parameters?: Record<string, unknown> | undefined;
+        }>, "many">>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        transitionId: string & z.BRAND<"TransitionId">;
+        from: string & z.BRAND<"StateId">;
+        to: string & z.BRAND<"StateId">;
+        signal: string & z.BRAND<"SignalId">;
+        allowedActors: ("human" | "automation" | "ai-agent")[];
+        description?: string | undefined;
+        guards?: {
+            guardId: string & z.BRAND<"GuardId">;
+            description: string;
+            severity: "hard" | "soft";
+            evaluatedBy: "runtime" | "module" | "external";
+            parameters?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }, {
+        transitionId: string;
+        from: string;
+        to: string;
+        signal: string;
+        allowedActors: ("human" | "automation" | "ai-agent")[];
+        description?: string | undefined;
+        guards?: {
+            guardId: string;
+            description: string;
+            severity: "hard" | "soft";
+            evaluatedBy: "runtime" | "module" | "external";
+            parameters?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }>, "many">;
+    outcome: z.ZodOptional<z.ZodObject<{
+        description: z.ZodString;
+        valueUnit: z.ZodString;
+        businessMetrics: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            unit: z.ZodString;
+            improvableByAI: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            label: string;
+            unit: string;
+            improvableByAI?: boolean | undefined;
+        }, {
+            id: string;
+            label: string;
+            unit: string;
+            improvableByAI?: boolean | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        valueUnit: string;
+        businessMetrics: {
+            id: string;
+            label: string;
+            unit: string;
+            improvableByAI?: boolean | undefined;
+        }[];
+    }, {
+        description: string;
+        valueUnit: string;
+        businessMetrics: {
+            id: string;
+            label: string;
+            unit: string;
+            improvableByAI?: boolean | undefined;
+        }[];
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    loopId: string & z.BRAND<"LoopId">;
+    version: string;
+    name: string;
+    states: {
+        stateId: string & z.BRAND<"StateId">;
+        label: string;
+        description?: string | undefined;
+        terminal?: boolean | undefined;
+    }[];
+    initialState: string & z.BRAND<"StateId">;
+    transitions: {
+        transitionId: string & z.BRAND<"TransitionId">;
+        from: string & z.BRAND<"StateId">;
+        to: string & z.BRAND<"StateId">;
+        signal: string & z.BRAND<"SignalId">;
+        allowedActors: ("human" | "automation" | "ai-agent")[];
+        description?: string | undefined;
+        guards?: {
+            guardId: string & z.BRAND<"GuardId">;
+            description: string;
+            severity: "hard" | "soft";
+            evaluatedBy: "runtime" | "module" | "external";
+            parameters?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }[];
+    outcome?: {
+        description: string;
+        valueUnit: string;
+        businessMetrics: {
+            id: string;
+            label: string;
+            unit: string;
+            improvableByAI?: boolean | undefined;
+        }[];
+    } | undefined;
+    tags?: string[] | undefined;
+}, {
+    description: string;
+    loopId: string;
+    version: string;
+    name: string;
+    states: {
+        stateId: string;
+        label: string;
+        description?: string | undefined;
+        terminal?: boolean | undefined;
+    }[];
+    initialState: string;
+    transitions: {
+        transitionId: string;
+        from: string;
+        to: string;
+        signal: string;
+        allowedActors: ("human" | "automation" | "ai-agent")[];
+        description?: string | undefined;
+        guards?: {
+            guardId: string;
+            description: string;
+            severity: "hard" | "soft";
+            evaluatedBy: "runtime" | "module" | "external";
+            parameters?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }[];
+    outcome?: {
+        description: string;
+        valueUnit: string;
+        businessMetrics: {
+            id: string;
+            label: string;
+            unit: string;
+            improvableByAI?: boolean | undefined;
+        }[];
+    } | undefined;
+    tags?: string[] | undefined;
+}>;
+type LoopDefinition = z.infer<typeof LoopDefinitionSchema>;
+
+declare const LOOP_ENGINE_CORE_VERSION = "0.1.0";
+
+export { type ActorId, ActorIdSchema, type ActorRef, ActorRefSchema, type ActorType, ActorTypeSchema, type AggregateId, AggregateIdSchema, type BusinessMetric, BusinessMetricSchema, type GuardId, GuardIdSchema, type GuardSeverity, GuardSeveritySchema, type GuardSpec, GuardSpecSchema, LOOP_ENGINE_CORE_VERSION, type LoopDefinition, LoopDefinitionSchema, type LoopId, LoopIdSchema, type LoopStatus, LoopStatusSchema, type OutcomeSpec, OutcomeSpecSchema, type SignalId, SignalIdSchema, type StateId, StateIdSchema, type StateSpec, StateSpecSchema, type TransitionId, TransitionIdSchema, type TransitionSpec, TransitionSpecSchema };

package/dist/index.js

@@ -1,4 +1,94 @@
-// @license MIT
-// SPDX-License-Identifier: MIT
-export * from "./types";
+// src/schemas.ts
+import { z } from "zod";
+var LoopIdSchema = z.string().brand();
+var AggregateIdSchema = z.string().brand();
+var ActorIdSchema = z.string().brand();
+var SignalIdSchema = z.string().brand();
+var GuardIdSchema = z.string().brand();
+var StateIdSchema = z.string().brand();
+var TransitionIdSchema = z.string().brand();
+var LoopStatusSchema = z.enum([
+  "pending",
+  "active",
+  "completed",
+  "failed",
+  "cancelled",
+  "suspended"
+]);
+var ActorTypeSchema = z.enum(["human", "automation", "ai-agent"]);
+var ActorRefSchema = z.object({
+  id: ActorIdSchema,
+  type: ActorTypeSchema,
+  displayName: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var GuardSeveritySchema = z.enum(["hard", "soft"]);
+var GuardSpecSchema = z.object({
+  guardId: GuardIdSchema,
+  description: z.string(),
+  severity: GuardSeveritySchema,
+  evaluatedBy: z.enum(["runtime", "module", "external"]),
+  parameters: z.record(z.unknown()).optional()
+});
+var TransitionSpecSchema = z.object({
+  transitionId: TransitionIdSchema,
+  from: StateIdSchema,
+  to: StateIdSchema,
+  signal: SignalIdSchema,
+  allowedActors: z.array(ActorTypeSchema).min(1),
+  guards: z.array(GuardSpecSchema).optional(),
+  description: z.string().optional()
+});
+var StateSpecSchema = z.object({
+  stateId: StateIdSchema,
+  label: z.string(),
+  terminal: z.boolean().optional(),
+  description: z.string().optional()
+});
+var BusinessMetricSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  unit: z.string(),
+  improvableByAI: z.boolean().optional()
+});
+var OutcomeSpecSchema = z.object({
+  description: z.string(),
+  valueUnit: z.string(),
+  businessMetrics: z.array(BusinessMetricSchema)
+});
+var LoopDefinitionSchema = z.object({
+  loopId: LoopIdSchema,
+  version: z.string(),
+  name: z.string(),
+  description: z.string(),
+  states: z.array(StateSpecSchema),
+  initialState: StateIdSchema,
+  transitions: z.array(TransitionSpecSchema),
+  outcome: OutcomeSpecSchema.optional(),
+  tags: z.array(z.string()).optional()
+});
+
+// src/index.ts
+var LOOP_ENGINE_CORE_VERSION = "0.1.0";
+export {
+  ActorIdSchema,
+  ActorRefSchema,
+  ActorTypeSchema,
+  AggregateIdSchema,
+  BusinessMetricSchema,
+  GuardIdSchema,
+  GuardSeveritySchema,
+  GuardSpecSchema,
+  LOOP_ENGINE_CORE_VERSION,
+  LoopDefinitionSchema,
+  LoopIdSchema,
+  LoopStatusSchema,
+  OutcomeSpecSchema,
+  SignalIdSchema,
+  StateIdSchema,
+  StateSpecSchema,
+  TransitionIdSchema,
+  TransitionSpecSchema
+};
+// @license Apache-2.0
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,+BAA+B;AAE/B,cAAc,SAAS,CAAC"}
+{"version":3,"sources":["../src/schemas.ts","../src/index.ts"],"sourcesContent":["// @license Apache-2.0\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from \"zod\";\n\nexport const LoopIdSchema = z.string().brand<\"LoopId\">();\nexport type LoopId = z.infer<typeof LoopIdSchema>;\n\nexport const AggregateIdSchema = z.string().brand<\"AggregateId\">();\nexport type AggregateId = z.infer<typeof AggregateIdSchema>;\n\nexport const ActorIdSchema = z.string().brand<\"ActorId\">();\nexport type ActorId = z.infer<typeof ActorIdSchema>;\n\nexport const SignalIdSchema = z.string().brand<\"SignalId\">();\nexport type SignalId = z.infer<typeof SignalIdSchema>;\n\nexport const GuardIdSchema = z.string().brand<\"GuardId\">();\nexport type GuardId = z.infer<typeof GuardIdSchema>;\n\nexport const StateIdSchema = z.string().brand<\"StateId\">();\nexport type StateId = z.infer<typeof StateIdSchema>;\n\nexport const TransitionIdSchema = z.string().brand<\"TransitionId\">();\nexport type TransitionId = z.infer<typeof TransitionIdSchema>;\n\nexport const LoopStatusSchema = z.enum([\n  \"pending\",\n  \"active\",\n  \"completed\",\n  \"failed\",\n  \"cancelled\",\n  \"suspended\"\n]);\nexport type LoopStatus = z.infer<typeof LoopStatusSchema>;\n\nexport const ActorTypeSchema = z.enum([\"human\", \"automation\", \"ai-agent\"]);\nexport type ActorType = z.infer<typeof ActorTypeSchema>;\n\nexport const ActorRefSchema = z.object({\n  id: ActorIdSchema,\n  type: ActorTypeSchema,\n  displayName: z.string().optional(),\n  metadata: z.record(z.unknown()).optional()\n});\nexport type ActorRef = z.infer<typeof ActorRefSchema>;\n\nexport const GuardSeveritySchema = z.enum([\"hard\", \"soft\"]);\nexport type GuardSeverity = z.infer<typeof GuardSeveritySchema>;\n\nexport const GuardSpecSchema = z.object({\n  guardId: GuardIdSchema,\n  description: z.string(),\n  severity: GuardSeveritySchema,\n  evaluatedBy: z.enum([\"runtime\", \"module\", \"external\"]),\n  parameters: z.record(z.unknown()).optional()\n});\nexport type GuardSpec = z.infer<typeof GuardSpecSchema>;\n\nexport const TransitionSpecSchema = z.object({\n  transitionId: TransitionIdSchema,\n  from: StateIdSchema,\n  to: StateIdSchema,\n  signal: SignalIdSchema,\n  allowedActors: z.array(ActorTypeSchema).min(1),\n  guards: z.array(GuardSpecSchema).optional(),\n  description: z.string().optional()\n});\nexport type TransitionSpec = z.infer<typeof TransitionSpecSchema>;\n\nexport const StateSpecSchema = z.object({\n  stateId: StateIdSchema,\n  label: z.string(),\n  terminal: z.boolean().optional(),\n  description: z.string().optional()\n});\nexport type StateSpec = z.infer<typeof StateSpecSchema>;\n\nexport const BusinessMetricSchema = z.object({\n  id: z.string(),\n  label: z.string(),\n  unit: z.string(),\n  improvableByAI: z.boolean().optional()\n});\nexport type BusinessMetric = z.infer<typeof BusinessMetricSchema>;\n\nexport const OutcomeSpecSchema = z.object({\n  description: z.string(),\n  valueUnit: z.string(),\n  businessMetrics: z.array(BusinessMetricSchema)\n});\nexport type OutcomeSpec = z.infer<typeof OutcomeSpecSchema>;\n\nexport const LoopDefinitionSchema = z.object({\n  loopId: LoopIdSchema,\n  version: z.string(),\n  name: z.string(),\n  description: z.string(),\n  states: z.array(StateSpecSchema),\n  initialState: StateIdSchema,\n  transitions: z.array(TransitionSpecSchema),\n  outcome: OutcomeSpecSchema.optional(),\n  tags: z.array(z.string()).optional()\n});\nexport type LoopDefinition = z.infer<typeof LoopDefinitionSchema>;\n","// @license Apache-2.0\n// SPDX-License-Identifier: Apache-2.0\n\nexport * from \"./schemas\";\n\nexport const LOOP_ENGINE_CORE_VERSION = \"0.1.0\";\n"],"mappings":";AAGA,SAAS,SAAS;AAEX,IAAM,eAAe,EAAE,OAAO,EAAE,MAAgB;AAGhD,IAAM,oBAAoB,EAAE,OAAO,EAAE,MAAqB;AAG1D,IAAM,gBAAgB,EAAE,OAAO,EAAE,MAAiB;AAGlD,IAAM,iBAAiB,EAAE,OAAO,EAAE,MAAkB;AAGpD,IAAM,gBAAgB,EAAE,OAAO,EAAE,MAAiB;AAGlD,IAAM,gBAAgB,EAAE,OAAO,EAAE,MAAiB;AAGlD,IAAM,qBAAqB,EAAE,OAAO,EAAE,MAAsB;AAG5D,IAAM,mBAAmB,EAAE,KAAK;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAGM,IAAM,kBAAkB,EAAE,KAAK,CAAC,SAAS,cAAc,UAAU,CAAC;AAGlE,IAAM,iBAAiB,EAAE,OAAO;AAAA,EACrC,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,aAAa,EAAE,OAAO,EAAE,SAAS;AAAA,EACjC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS;AAC3C,CAAC;AAGM,IAAM,sBAAsB,EAAE,KAAK,CAAC,QAAQ,MAAM,CAAC;AAGnD,IAAM,kBAAkB,EAAE,OAAO;AAAA,EACtC,SAAS;AAAA,EACT,aAAa,EAAE,OAAO;AAAA,EACtB,UAAU;AAAA,EACV,aAAa,EAAE,KAAK,CAAC,WAAW,UAAU,UAAU,CAAC;AAAA,EACrD,YAAY,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS;AAC7C,CAAC;AAGM,IAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,cAAc;AAAA,EACd,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,QAAQ;AAAA,EACR,eAAe,EAAE,MAAM,eAAe,EAAE,IAAI,CAAC;AAAA,EAC7C,QAAQ,EAAE,MAAM,eAAe,EAAE,SAAS;AAAA,EAC1C,aAAa,EAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAGM,IAAM,kBAAkB,EAAE,OAAO;AAAA,EACtC,SAAS;AAAA,EACT,OAAO,EAAE,OAAO;AAAA,EAChB,UAAU,EAAE,QAAQ,EAAE,SAAS;AAAA,EAC/B,aAAa,EAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAGM,IAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,IAAI,EAAE,OAAO;AAAA,EACb,OAAO,EAAE,OAAO;AAAA,EAChB,MAAM,EAAE,OAAO;AAAA,EACf,gBAAgB,EAAE,QAAQ,EAAE,SAAS;AACvC,CAAC;AAGM,IAAM,oBAAoB,EAAE,OAAO;AAAA,EACxC,aAAa,EAAE,OAAO;AAAA,EACtB,WAAW,EAAE,OAAO;AAAA,EACpB,iBAAiB,EAAE,MAAM,oBAAoB;AAC/C,CAAC;AAGM,IAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,QAAQ;AAAA,EACR,SAAS,EAAE,OAAO;AAAA,EAClB,MAAM,EAAE,OAAO;AAAA,EACf,aAAa,EAAE,OAAO;AAAA,EACtB,QAAQ,EAAE,MAAM,eAAe;AAAA,EAC/B,cAAc;AAAA,EACd,aAAa,EAAE,MAAM,oBAAoB;AAAA,EACzC,SAAS,kBAAkB,SAAS;AAAA,EACpC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS;AACrC,CAAC;;;AClGM,IAAM,2BAA2B;","names":[]}

package/package.json

@@ -1,28 +1,34 @@
 {
   "name": "@loop-engine/core",
-  "version": "0.1.0",
-  "license": "MIT",
-  "description": "Domain model types for the Loop Engine - zero dependencies",
+  "version": "0.1.1",
+  "license": "Apache-2.0",
+  "description": "Core domain model and schemas for Loop Engine",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     }
   },
-  "dependencies": {},
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {},
   "files": [
     "dist/",
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run"
+  "engines": {
+    "node": ">=18.0.0"
   }
-}
+}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,SAAS,CAAC"}

package/dist/types.d.ts

@@ -1,138 +0,0 @@
-export type LoopId = string & {
-    readonly __brand: "LoopId";
-};
-export type StateId = string & {
-    readonly __brand: "StateId";
-};
-export type TransitionId = string & {
-    readonly __brand: "TransitionId";
-};
-export type AggregateId = string & {
-    readonly __brand: "AggregateId";
-};
-export type ActorId = string & {
-    readonly __brand: "ActorId";
-};
-export type GuardId = string & {
-    readonly __brand: "GuardId";
-};
-export type SignalId = string & {
-    readonly __brand: "SignalId";
-};
-export type OutcomeId = string & {
-    readonly __brand: "OutcomeId";
-};
-export type CorrelationId = string & {
-    readonly __brand: "CorrelationId";
-};
-export declare function loopId(s: string): LoopId;
-export declare function stateId(s: string): StateId;
-export declare function transitionId(s: string): TransitionId;
-export declare function aggregateId(s: string): AggregateId;
-export declare function actorId(s: string): ActorId;
-export declare function guardId(s: string): GuardId;
-export declare function signalId(s: string): SignalId;
-export declare function outcomeId(s: string): OutcomeId;
-export declare function correlationId(s: string): CorrelationId;
-export type ActorType = "human" | "automation" | "ai-agent" | "webhook" | "system";
-export type LoopStatus = "OPEN" | "IN_PROGRESS" | "CLOSED" | "ERROR" | "CANCELLED";
-export interface GuardSpec {
-    id: GuardId;
-    description: string;
-    failureMessage: string;
-    severity: "hard" | "soft";
-    evaluatedBy: "runtime" | "module" | "external";
-}
-export interface BusinessMetric {
-    id: string;
-    label: string;
-    unit: "boolean" | "days" | "units" | "currency" | "percentage" | string;
-    improvableByAI: boolean;
-}
-export interface OutcomeSpec {
-    id: OutcomeId;
-    description: string;
-    valueUnit: string;
-    measurable: boolean;
-    businessMetrics?: BusinessMetric[];
-}
-export interface SideEffectSpec {
-    id: string;
-    description: string;
-    triggeredBy: TransitionId;
-}
-export interface TransitionSpec {
-    id: TransitionId;
-    from: StateId;
-    to: StateId;
-    allowedActors: ActorType[];
-    guards?: GuardSpec[];
-    sideEffects?: SideEffectSpec[];
-    description?: string;
-}
-export interface StateSpec {
-    id: StateId;
-    description?: string;
-    isTerminal?: boolean;
-    isError?: boolean;
-}
-export interface LoopDefinition {
-    id: LoopId;
-    version: string;
-    description: string;
-    domain: string;
-    states: StateSpec[];
-    initialState: StateId;
-    transitions: TransitionSpec[];
-    outcome: OutcomeSpec;
-    participants?: string[];
-    spawnableLoops?: LoopId[];
-    metadata?: Record<string, unknown>;
-}
-export interface LoopRegistry {
-    get(loopId: LoopId): LoopDefinition | undefined;
-    list(domain?: string): LoopDefinition[];
-}
-export interface ActorRef {
-    type: ActorType;
-    id: ActorId;
-    displayName?: string;
-    sessionId?: string;
-    agentId?: string;
-}
-export interface Evidence {
-    [key: string]: unknown;
-}
-export interface LoopInstance {
-    loopId: LoopId;
-    aggregateId: AggregateId;
-    orgId: string;
-    currentState: StateId;
-    status: LoopStatus;
-    startedAt: string;
-    closedAt?: string;
-    correlationId: CorrelationId;
-    metadata?: Record<string, unknown>;
-}
-export interface TransitionRecord {
-    id: string;
-    loopId: LoopId;
-    aggregateId: AggregateId;
-    transitionId: TransitionId;
-    fromState: StateId;
-    toState: StateId;
-    actor: ActorRef;
-    evidence: Evidence;
-    occurredAt: string;
-    durationMs?: number;
-}
-export interface Signal {
-    id: SignalId;
-    type: string;
-    subject: string;
-    confidence?: number;
-    observedAt: string;
-    payload: Record<string, unknown>;
-    triggeredLoopId?: LoopId;
-}
-//# sourceMappingURL=types.d.ts.map