@pikku/inspector 0.12.60 → 0.12.62

package/src/utils/get-property-value.ts

@@ -127,6 +127,46 @@ export const assertStringLiteralProperty = (
   }
 }
 
+/**
+ * Fold a node that is a compile-time constant string down to its value.
+ *
+ * The fallback below this is `getText()`, which returns the node's *source*.
+ * For a lone `'…'` that is indistinguishable from the value, so nobody noticed
+ * that anything written as an expression comes through raw: a `description`
+ * split across lines as `'Fetch the thing ' + 'from upstream'` reaches
+ * `infra.json` with the quotes and the `+` still in it, and is rendered that
+ * way in the fabric console.
+ *
+ * Deliberately checker-free, unlike `extractStringLiteral`. Every value this
+ * resolves is a literal in the same expression, so no symbol resolution is
+ * needed, and `getPropertyValue` is called from a dozen places that have no
+ * checker to hand. Anything it cannot fold — an identifier, a template with a
+ * substitution — returns `undefined` and takes the old path, so this only ever
+ * turns a wrong answer into a right one.
+ */
+const foldStaticString = (node: ts.Node): string | undefined => {
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text
+  }
+  if (ts.isParenthesizedExpression(node)) {
+    return foldStaticString(node.expression)
+  }
+  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+    return foldStaticString(node.expression)
+  }
+  if (
+    ts.isBinaryExpression(node) &&
+    node.operatorToken.kind === ts.SyntaxKind.PlusToken
+  ) {
+    const left = foldStaticString(node.left)
+    if (left === undefined) return undefined
+    const right = foldStaticString(node.right)
+    if (right === undefined) return undefined
+    return left + right
+  }
+  return undefined
+}
+
 export const getPropertyValue = (
   obj: ts.ObjectLiteralExpression,
   propertyName: string
@@ -174,11 +214,9 @@ export const getPropertyValue = (
       return Number(initializer.text)
     }
 
-    if (
-      ts.isStringLiteral(initializer) ||
-      ts.isNoSubstitutionTemplateLiteral(initializer)
-    ) {
-      return initializer.text
+    const staticString = foldStaticString(initializer)
+    if (staticString !== undefined) {
+      return staticString
     }
 
     return initializer.getText()

package/src/utils/load-addon-functions-meta.ts

@@ -1,3 +1,4 @@
+import { existsSync } from 'fs'
 import { readFile, readdir } from 'fs/promises'
 import { createRequire } from 'module'
 import { join, dirname } from 'path'
@@ -141,6 +142,44 @@ const resolveAddonMeta = (
   return null
 }
 
+/**
+ * Give the addon's input/output type names a declaration file to be imported
+ * from, so a wiring that references an addon function can name its contract.
+ *
+ * Without this the only thing that knows where `GetScenarioArtifactInput` lives
+ * is the type checker, and it only knows once the consumer's *own* rpc map has
+ * already been generated with the addon's routes in it — which is to say on the
+ * second run. A first, cold run resolved `ref('console:getScenarioArtifact')`
+ * against a map that did not mention it yet and fell back to the whole
+ * `FlattenedRPCMap`, so the same source produced a different http-map depending
+ * on whether `.pikku` happened to be there. The addon publishes these types at a
+ * fixed subpath; reading them from the metadata makes the first run agree with
+ * the second.
+ */
+const registerAddonTypes = (
+  state: InspectorState,
+  metaPath: string,
+  meta: Record<string, any>
+): void => {
+  // Derived from the metadata's own location rather than resolved as a package
+  // subpath: the addon exports that declaration under a `types`-only condition,
+  // which `require.resolve` will not follow.
+  const typesPath = join(
+    dirname(metaPath),
+    '..',
+    'rpc',
+    'pikku-rpc-wirings-map.internal.gen.d.ts'
+  )
+  if (!existsSync(typesPath)) return
+
+  for (const funcMeta of Object.values(meta)) {
+    for (const name of [funcMeta.inputSchemaName, funcMeta.outputSchemaName]) {
+      if (!name || state.functions.typesMap.exists(name, typesPath)) continue
+      state.functions.typesMap.addType(name, typesPath)
+    }
+  }
+}
+
 /**
  * After the setup sweep discovers wireAddon() declarations, load each addon
  * package's function metadata so that wiring handlers (channels, HTTP routes,
@@ -177,6 +216,7 @@ export async function loadAddonFunctionsMeta(
       logger.debug(
         `Loaded ${Object.keys(meta).length} addon functions for '${namespace}' from ${decl.package}`
       )
+      registerAddonTypes(state, metaPath, meta)
 
       // If wireAddon has mcp: true, expose addon functions with mcp: true as MCP tools
       if (decl.mcp) {

package/src/utils/middleware.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import type { MiddlewareMetadata } from '@pikku/core/ecosystem/types'
+import type { MiddlewareMetadata } from '@pikku/core/middleware'
 import { extractFunctionName } from './extract-function-name.js'
 import type { InspectorState } from '../types.js'
 

package/src/utils/permissions.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import type { PermissionMetadata } from '@pikku/core/ecosystem/types'
+import type { PermissionMetadata } from '@pikku/core/function'
 import { extractFunctionName } from './extract-function-name.js'
 import type { InspectorState } from '../types.js'
 

package/src/utils/post-process.test.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert'
 import { describe, test } from 'node:test'
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs'
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import {
@@ -579,10 +579,67 @@ describe('validateRemoteAddonDependencies (wireRemoteAddon must be a devDependen
     }
   })
 
-  test('ignores a non-remote (wireAddon) declaration', () => {
+  test('a non-remote (wireAddon) declaration is judged on resolvability, not package.json', () => {
+    // Being listed as a dependency is not what makes an addon usable — it is
+    // discovered because it is wired, and it can arrive by workspace link or a
+    // local addons/ directory without ever appearing here. So a declared but
+    // absent package is still an error.
     const { logger, criticals } = makeCriticalLogger()
     const dir = writePkg({ '@addon/local': '1.0.0' }, {})
     try {
+      validateRemoteAddonDependencies(
+        logger,
+        makeRemoteState(dir, { package: '@addon/local' })
+      )
+      assert.equal(criticals.length, 1)
+      assert.equal(criticals[0]!.code, ErrorCode.ADDON_NOT_INSTALLED)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('a non-remote addon present only in node_modules passes', () => {
+    // The inverse, and the case that matters: installed by link, absent from
+    // package.json. Reported as missing, this would fail every project whose
+    // addon lives in a local addons/ directory.
+    const { logger, criticals } = makeCriticalLogger()
+    const dir = writePkg({}, {})
+    try {
+      const pkgDir = join(dir, 'node_modules', '@addon', 'local')
+      mkdirSync(pkgDir, { recursive: true })
+      writeFileSync(
+        join(pkgDir, 'package.json'),
+        JSON.stringify({ name: '@addon/local', version: '1.0.0' })
+      )
+      validateRemoteAddonDependencies(
+        logger,
+        makeRemoteState(dir, { package: '@addon/local' })
+      )
+      assert.deepEqual(criticals, [])
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('an exports map that refuses package.json is not read as missing', () => {
+    // `require.resolve('<pkg>/package.json')` throws ERR_PACKAGE_PATH_NOT_EXPORTED
+    // on a package with a restrictive exports map. Reaching the exports map
+    // means the package was found, so that must not count as absent.
+    const { logger, criticals } = makeCriticalLogger()
+    const dir = writePkg({}, {})
+    try {
+      const pkgDir = join(dir, 'node_modules', '@addon', 'local')
+      mkdirSync(pkgDir, { recursive: true })
+      writeFileSync(
+        join(pkgDir, 'package.json'),
+        JSON.stringify({
+          name: '@addon/local',
+          version: '1.0.0',
+          main: 'index.js',
+          exports: { '.': './index.js' },
+        })
+      )
+      writeFileSync(join(pkgDir, 'index.js'), 'module.exports = {}\n')
       validateRemoteAddonDependencies(
         logger,
         makeRemoteState(dir, { package: '@addon/local' })

package/src/utils/post-process.ts

@@ -7,19 +7,20 @@ import type {
 } from '../types.js'
 import type {
   FunctionServicesMeta,
-  MiddlewareMetadata,
   PermissionMetadata,
-} from '@pikku/core/ecosystem/types'
+} from '@pikku/core/function'
+import type { MiddlewareMetadata } from '@pikku/core/middleware'
 import type ts from 'typescript'
 import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import { join } from 'node:path'
 import { extractTypeKeys } from './type-utils.js'
 import { ErrorCode } from '../error-codes.js'
 import { findSecretAliasServices } from './secret-alias-services.js'
 import { relative } from 'node:path'
 import { AUTH_HANDLER_FUNC_ID } from '../add/add-auth.js'
-import { flattenScopeDefinitions } from '@pikku/core/ecosystem/scope'
-import type { WorkflowStepMeta } from '@pikku/core/ecosystem/workflow'
+import { flattenScopeDefinitions } from '@pikku/core/scope'
+import type { WorkflowStepMeta } from '@pikku/core/workflow'
 import { DYNAMIC_SCENARIO_STEP_TARGET } from './workflow/dsl/patterns.js'
 
 /**
@@ -480,10 +481,56 @@ export function validateVariableOverrides(
 }
 
 /**
+ * Can `pkg` be resolved from `rootDir`, by any means the loader would use?
+ *
+ * Resolution is attempted against `<pkg>/package.json` first and the bare
+ * specifier second, because neither alone is conclusive. A package with a
+ * restrictive `exports` map refuses the first with
+ * `ERR_PACKAGE_PATH_NOT_EXPORTED` — which is not a failure at all: reaching the
+ * exports map means the package was found. Only a module-not-found from both
+ * attempts means it is genuinely absent.
+ */
+const isPackageResolvable = (pkg: string, rootDir: string): boolean => {
+  const NOT_FOUND = new Set(['MODULE_NOT_FOUND', 'ERR_MODULE_NOT_FOUND'])
+  let req: ReturnType<typeof createRequire>
+  try {
+    req = createRequire(join(rootDir, 'package.json'))
+  } catch {
+    return true // cannot ask; do not accuse
+  }
+  for (const specifier of [`${pkg}/package.json`, pkg]) {
+    try {
+      req.resolve(specifier)
+      return true
+    } catch (e: any) {
+      if (!NOT_FOUND.has(e?.code)) return true
+    }
+  }
+  return false
+}
+
+/**
+ * Every wired addon must be installed, in the bucket matching how it is used.
+ *
  * A `wireRemoteAddon` package ships types only — its handlers run on the host —
  * so it MUST be a devDependency, not a production dependency (a prod dep would
- * drag in the runtime deps remote consumption exists to avoid). This is the
- * mirror image of `wireAddon`, which requires a production dependency.
+ * drag in the runtime deps remote consumption exists to avoid).
+ *
+ * A plain `wireAddon` only has to be *resolvable*. The failure it allows is
+ * quiet in a way the remote one is not — an absent package makes the metadata
+ * load fail, which is caught and downgraded to a warning, so every
+ * `ref('<namespace>:…')` resolves against nothing and the surface is dead at
+ * runtime. The generated console is the common case: `scaffold.console` emits
+ * `wireAddon({ package: '@pikku/addon-console' })` and refs into it, and a
+ * project that never installed the package gets a console that 404s with
+ * nothing in the build output saying why.
+ *
+ * Deliberately a resolution check and not a `package.json` one. An addon is
+ * discovered because it is *wired*, not because it is a declared dependency —
+ * addons arrive by workspace link, by a local `addons/` directory recorded in
+ * `pikku-addons.json`, and by plain install, and only the last of those shows
+ * up in `dependencies`. Asking the resolver is the only question that matches
+ * what the loader will actually do.
  */
 export function validateRemoteAddonDependencies(
   logger: InspectorLogger,
@@ -492,10 +539,19 @@ export function validateRemoteAddonDependencies(
   const { wireAddonDeclarations } = state.rpc
   if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) return
 
-  const hasRemote = Array.from(wireAddonDeclarations.values()).some(
-    (d) => d.remote
-  )
-  if (!hasRemote) return
+  // Local addons first, and independently of the manifest below: their check
+  // asks the resolver, not `package.json`, so a project without a manifest (as
+  // in some tests) must not skip it.
+  for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+    if (decl.remote) continue
+    if (isPackageResolvable(decl.package, state.rootDir)) continue
+    logger.critical(
+      ErrorCode.ADDON_NOT_INSTALLED,
+      `Addon '${namespace}' ('${decl.package}') is wired with wireAddon but cannot be resolved — every ref('${namespace}:…') will resolve to nothing and the surface will be dead at runtime. Install it, or remove the wireAddon call.`
+    )
+  }
+
+  if (!Array.from(wireAddonDeclarations.values()).some((d) => d.remote)) return
 
   const pkgJsonPath = join(state.rootDir, 'package.json')
   if (!existsSync(pkgJsonPath)) return // no manifest to check (e.g. some tests)
@@ -724,10 +780,7 @@ export function computeRequiredSchemas(
  * the functions that are actually invoked, so this blocks CI through
  * `--fail-on-error` without failing a dev server over a function nobody calls.
  */
-export function validateSchemaReferences(
-  logger: InspectorLogger,
-  state: InspectorState
-): void {
+export function unresolvedSchemaReferences(state: InspectorState): string[] {
   const { functions, schemas } = state
   const available = new Set(Object.keys(schemas ?? {}))
   const unresolved: string[] = []
@@ -752,6 +805,15 @@ export function validateSchemaReferences(
     }
   }
 
+  return unresolved
+}
+
+export function validateSchemaReferences(
+  logger: InspectorLogger,
+  state: InspectorState
+): void {
+  const unresolved = unresolvedSchemaReferences(state)
+
   if (unresolved.length === 0) return
 
   logger.diagnostic({
@@ -842,10 +904,11 @@ export function validateScenarioServices(
  *
  * - the step target must be a static string literal (PKU678) — otherwise it
  *   can't be bundled, typed or drawn;
- * - a step declaring a `browser` binding must be given an actor (PKU677), since
- *   the browser context signs in as that persona. It is checked statically even
- *   though the binding only runs on a browser run: a step that can never be
- *   driven by a human is a latent failure, not a passing default run.
+ * - a step that runs as a persona must be given one (PKU677) — declared by
+ *   `actor: true`, or implied by a `browser` binding, since the browser context
+ *   signs in as that persona. It is checked statically even though a browser
+ *   binding only runs on a browser run: a step that can never be driven by a
+ *   human is a latent failure, not a passing default run.
  * - a scenario written as a step ladder must assert something (PKU680).
  *
  * It also marks the step's function as used, so `scenario run` boots the
@@ -872,14 +935,14 @@ export function validateScenarioSteps(
         }
         state.serviceAggregation.usedFunctions.add(step.stepFunc)
         const stepMeta = state.functions.meta[step.stepFunc]
-        if (
-          stepMeta?.scenarioStepSurfaces?.includes('browser') &&
-          !step.actor
-        ) {
+        if (stepMeta?.scenarioStepRequiresActor && !step.actor) {
+          const why = stepMeta.scenarioStepSurfaces?.includes('browser')
+            ? 'declares a browser binding'
+            : 'is driven by a persona'
           logger.critical(
-            ErrorCode.SCENARIO_BROWSER_STEP_NEEDS_ACTOR,
-            `Scenario '${workflowName}' calls step '${step.stepFunc}', which declares a browser binding, without an actor. ` +
-              `Pass { actor: actors.<name> } so the browser context signs in as that persona.`
+            ErrorCode.SCENARIO_STEP_NEEDS_ACTOR,
+            `Scenario '${workflowName}' calls step '${step.stepFunc}', which ${why}, without an actor. ` +
+              `Pass { actor: actors.<name> } so it runs as that persona.`
           )
         }
         continue

package/src/utils/resolve-deploy-target.ts

@@ -1,4 +1,4 @@
-import type { FunctionMeta } from '@pikku/core/ecosystem/services'
+import type { FunctionMeta } from '@pikku/core/services'
 
 /**
  * Thrown when a function's explicit `deploy: 'serverless'` conflicts

package/src/utils/resolve-function-meta.ts

@@ -1,7 +1,4 @@
-import type {
-  FunctionMeta,
-  FunctionsMeta,
-} from '@pikku/core/ecosystem/services'
+import type { FunctionMeta, FunctionsMeta } from '@pikku/core/services'
 
 /**
  * Look up function metadata by pikkuFuncId, checking both local functions

package/src/utils/resolve-function-types.ts

@@ -1,5 +1,5 @@
 import type { TypesMap } from '../types-map.js'
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services'
+import type { FunctionsMeta } from '@pikku/core/services'
 
 export function resolveFunctionIOTypes(
   pikkuFuncId: string,

package/src/utils/resolve-versions.ts

@@ -1,8 +1,5 @@
-import {
-  parseVersionedId,
-  formatVersionedId,
-} from '@pikku/core/ecosystem/types'
-import type { CLICommandMeta } from '@pikku/core/ecosystem/cli'
+import { parseVersionedId, formatVersionedId } from '@pikku/core/utils'
+import type { CLICommandMeta } from '@pikku/core/cli'
 import type { InspectorState, InspectorLogger } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 

package/src/utils/schema-generator.ts

@@ -12,9 +12,9 @@ import { createGenerator, RootlessError } from 'ts-json-schema-generator'
 import { register } from 'tsx/esm/api'
 import * as z from 'zod'
 import { zodToTs, createAuxiliaryTypeStore } from 'zod-to-ts'
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services'
-import type { JSONValue } from '@pikku/core/ecosystem/types'
-import type { HTTPWiringsMeta } from '@pikku/core/ecosystem/http'
+import type { FunctionsMeta } from '@pikku/core/services'
+import type { JSONValue } from '@pikku/core/utils'
+import type { HTTPWiringsMeta } from '@pikku/core/http'
 import type { TypesMap } from '../types-map.js'
 import { ErrorCode } from '../error-codes.js'
 import type { InspectorLogger, InspectorState, SchemaRef } from '../types.js'

package/src/utils/serialize-inspector-state.ts

@@ -1,5 +1,5 @@
 import type { SecretUsage } from './extract-secret-usage.js'
-import type { JSONValue } from '@pikku/core/ecosystem/types'
+import type { JSONValue } from '@pikku/core/utils'
 import type {
   InspectorDiagnostic,
   InspectorFeature,
@@ -212,6 +212,7 @@ export interface SerializableInspectorState {
     files: string[]
     usage: Record<string, SecretUsage>
   }
+  surfaceUsage: InspectorState['surfaceUsage']
   credentials: {
     definitions: InspectorState['credentials']['definitions']
     files: string[]
@@ -440,6 +441,7 @@ export function serializeInspectorState(
       files: Array.from(state.secrets.files),
       usage: Object.fromEntries(state.secrets.usage),
     },
+    surfaceUsage: state.surfaceUsage,
     credentials: {
       definitions: state.credentials.definitions,
       files: Array.from(state.credentials.files),
@@ -648,6 +650,7 @@ export function deserializeInspectorState(
       files: new Set(data.secrets?.files || []),
       usage: new Map(Object.entries(data.secrets?.usage || {})),
     },
+    surfaceUsage: data.surfaceUsage || {},
     credentials: {
       definitions: data.credentials?.definitions || [],
       files: new Set(data.credentials?.files || []),

package/src/utils/serialize-mcp-json.ts

@@ -1,5 +1,5 @@
 import type { InspectorLogger, InspectorState } from '../types.js'
-import type { JSONValue } from '@pikku/core/ecosystem/types'
+import type { JSONValue } from '@pikku/core/utils'
 import { resolveFunctionMeta } from './resolve-function-meta.js'
 
 interface MCPEndpoint {

package/src/utils/serialize-openapi-json.ts

@@ -1,5 +1,5 @@
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services'
-import type { HTTPWiringsMeta } from '@pikku/core/ecosystem/http'
+import type { FunctionsMeta } from '@pikku/core/services'
+import type { HTTPWiringsMeta } from '@pikku/core/http'
 import type { InspectorLogger } from '../types.js'
 import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
 const convertSchema =

package/src/utils/validate-auth-sessionless.ts

@@ -2,6 +2,7 @@ import type * as ts from 'typescript'
 import { getPropertyValue } from './get-property-value.js'
 import { ErrorCode } from '../error-codes.js'
 import type { InspectorLogger, InspectorState } from '../types.js'
+import { resolveFunctionMeta } from './resolve-function-meta.js'
 
 export function validateAuthSessionless(
   logger: InspectorLogger,
@@ -11,7 +12,7 @@ export function validateAuthSessionless(
   wireDescription: string,
   inheritedAuth?: boolean
 ): boolean {
-  const fnMeta = state.functions.meta[funcName]
+  const fnMeta = resolveFunctionMeta(state, funcName)
   if (!fnMeta) return true
 
   const routeAuth = getPropertyValue(obj, 'auth')

package/src/utils/validate-tags-resolve-to-middleware.test.ts

@@ -59,7 +59,10 @@ describe('validateTagsResolveToMiddleware', () => {
   })
 
   test('stays quiet when http middleware is registered for the tag', () => {
-    assert.deepEqual(run(stateWith({ console: { tags: ['admin'] } }, ['admin'])), [])
+    assert.deepEqual(
+      run(stateWith({ console: { tags: ['admin'] } }, ['admin'])),
+      []
+    )
   })
 
   test('stays quiet when only channel middleware is registered for the tag', () => {

package/src/utils/workflow/derive-workflow-plan.test.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from 'assert'
 import { describe, test } from 'node:test'
-import type { WorkflowStepMeta } from '@pikku/core/ecosystem/workflow'
+import type { WorkflowStepMeta } from '@pikku/core/workflow'
 import { deriveWorkflowPlan } from './derive-workflow-plan.js'
 
 const rpc = (stepName: string, rpcName = 'rpc.fn'): WorkflowStepMeta =>

package/src/utils/workflow/derive-workflow-plan.ts

@@ -1,7 +1,7 @@
 import type {
   WorkflowStepMeta,
   WorkflowPlannedStep,
-} from '@pikku/core/ecosystem/workflow'
+} from '@pikku/core/workflow'
 
 /**
  * Derive the static UI plan for a DSL workflow from its extracted step tree.

package/src/utils/workflow/dsl/extract-approval-policy.test.ts

@@ -2,7 +2,7 @@ import { describe, test } from 'node:test'
 import assert from 'node:assert/strict'
 import * as ts from 'typescript'
 import { extractDSLWorkflow } from './extract-dsl-workflow.js'
-import type { ApprovalStepMeta } from '@pikku/core/ecosystem/workflow'
+import type { ApprovalStepMeta } from '@pikku/core/workflow'
 
 const checker = {
   getSymbolAtLocation: () => undefined,

package/src/utils/workflow/dsl/extract-dsl-workflow.ts

@@ -20,8 +20,8 @@ import type {
   Condition,
   WorkflowContext,
   ContextVariable,
-} from '@pikku/core/ecosystem/workflow'
-import type { ScenarioStepMeta } from '@pikku/core/ecosystem/scenario'
+} from '@pikku/core/workflow'
+import type { ScenarioStepMeta } from '@pikku/core/scenario'
 import {
   isWorkflowDoCall,
   isWorkflowExpectEventuallyCall,

package/src/utils/workflow/graph/convert-dsl-to-graph-skip.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'node:test'
 import assert from 'node:assert'
 import { convertDslToGraph } from './convert-dsl-to-graph.js'
-import type { WorkflowsMeta } from '@pikku/core/ecosystem/workflow'
+import type { WorkflowsMeta } from '@pikku/core/workflow'
 
 const scenarioMeta = (
   overrides: Partial<WorkflowsMeta[string]> = {}

package/src/utils/workflow/graph/convert-dsl-to-graph.ts

@@ -1,10 +1,7 @@
 /**
  * Converts DSL (Domain Specific Language) step-based format to graph node format
  */
-import type {
-  WorkflowStepMeta,
-  WorkflowsMeta,
-} from '@pikku/core/ecosystem/workflow'
+import type { WorkflowStepMeta, WorkflowsMeta } from '@pikku/core/workflow'
 import type {
   SerializedGraphNode,
   SerializedWorkflowGraph,

package/src/utils/workflow/graph/finalize-workflow-wires.ts

@@ -3,7 +3,7 @@ import type {
   SerializedWorkflowGraph,
   WorkflowWires,
 } from './workflow-graph.types.js'
-import type { CLICommandMeta } from '@pikku/core/ecosystem/cli'
+import type { CLICommandMeta } from '@pikku/core/cli'
 
 function parseWorkflowFuncId(
   pikkuFuncId: string

package/src/utils/workflow/graph/finalize-workflows.ts

@@ -1,9 +1,9 @@
-import type { FunctionsMeta } from '@pikku/core/ecosystem/services'
+import type { FunctionsMeta } from '@pikku/core/services'
 import {
   isVersionedId,
   formatVersionedId,
   parseVersionedId,
-} from '@pikku/core/ecosystem/types'
+} from '@pikku/core/utils'
 import type { SerializedWorkflowGraph } from './workflow-graph.types.js'
 import { canonicalJSON, hashString } from '../../hash.js'
 import { convertDslToGraph } from './convert-dsl-to-graph.js'

package/src/utils/workflow/graph/index.ts

@@ -1,7 +1,24 @@
 /**
  * Workflow graph serialization exports
  */
-export * from './workflow-graph.types.js'
+export {
+  isDataRef,
+  isFunctionNode,
+  ref,
+  state,
+} from './workflow-graph.types.js'
+export type {
+  BranchCondition,
+  ContextVariable,
+  DataRef,
+  FlowNode,
+  ForEachMode,
+  FunctionNode,
+  NodeOptions,
+  SerializedWorkflowGraph,
+  SerializedWorkflowGraphs,
+  WorkflowContext,
+} from './workflow-graph.types.js'
 export { serializeWorkflowGraph } from './serialize-workflow-graph.js'
 export { convertDslToGraph } from './convert-dsl-to-graph.js'
 export { finalizeWorkflows } from './finalize-workflows.js'