@inf-monkeys-tech/monkeys 1.0.68 → 1.0.70

package/lib/esm/runtime/index.mjs

@@ -10076,6 +10076,12 @@ var ResolvedNavigationTargetSchema = z9.object({
   targetRevisionRef: RevisionRefSchema,
   releaseRevisionRef: RevisionRefSchema.optional()
 }).strict();
+var UnavailableNavigationTargetSchema = z9.object({
+  nodeId: ContractIdentifierSchema,
+  stableTargetRef: StableRefSchema.refine((reference) => reference.kind === "page", "Only missing Pages can be isolated."),
+  reason: z9.literal("page-missing"),
+  accessPolicy: AccessPolicySchema.nullable()
+}).strict();
 var NavigationReleaseSchema = z9.object({
   contract: z9.literal("NavigationRelease"),
   ...ReleaseBaseShape,
@@ -10085,13 +10091,17 @@ var NavigationReleaseSchema = z9.object({
     surface: ProductSurfaceSchema,
     placement: ContractIdentifierSchema
   }).strict(),
-  resolvedTargets: z9.array(ResolvedNavigationTargetSchema)
+  resolvedTargets: z9.array(ResolvedNavigationTargetSchema),
+  unavailableTargets: z9.array(UnavailableNavigationTargetSchema).optional()
 }).strict().superRefine((value, context) => {
   validateDependencySnapshot(value.dependencySnapshot, context);
   validateReleaseExpectedHead(value, "navigation-release", context);
   if (value.navigationRevisionRef.kind !== "navigation") context.addIssue({ code: "custom", path: ["navigationRevisionRef", "kind"], message: "Expected a navigation revision." });
   if (value.target.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["target", "environmentRef", "kind"], message: "Navigation release target requires an environment reference." });
   if (uniqueArray(value.resolvedTargets, (target) => target.nodeId)) context.addIssue({ code: "custom", path: ["resolvedTargets"], message: "Resolved Navigation node IDs must be unique." });
+  if (uniqueArray([...value.resolvedTargets, ...value.unavailableTargets ?? []], (target) => target.nodeId)) {
+    context.addIssue({ code: "custom", path: ["unavailableTargets"], message: "Navigation target resolutions must have unique node IDs." });
+  }
 });
 var RuntimeDiagnosticSchema = z9.object({
   code: ContractIdentifierSchema,
@@ -10179,7 +10189,8 @@ var CompiledNavigationDomainCommandTargetSchema = ResolvedNavigationTargetSchema
 var CompiledNavigationResolvedTargetSchema = z9.discriminatedUnion("kind", [
   CompiledNavigationTargetSchema,
   CompiledNavigationRegisteredMenuActionTargetSchema,
-  CompiledNavigationDomainCommandTargetSchema
+  CompiledNavigationDomainCommandTargetSchema,
+  UnavailableNavigationTargetSchema.omit({ reason: true }).extend({ kind: z9.literal("unavailable") }).strict()
 ]);
 var CompiledNavigationGroupNodeSchema = NavigationGroupNodeSchema.extend({
   ancestorAccessPolicies: z9.array(AccessPolicySchema)
@@ -10187,7 +10198,14 @@ var CompiledNavigationGroupNodeSchema = NavigationGroupNodeSchema.extend({
 var CompiledNavigationTargetNodeSchema = NavigationTargetNodeSchema.extend({
   ancestorAccessPolicies: z9.array(AccessPolicySchema),
   resolvedTarget: CompiledNavigationResolvedTargetSchema
-}).strict();
+}).strict().superRefine((node, context) => {
+  if (node.resolvedTarget.nodeId !== node.nodeId || stableRefIdentity(node.resolvedTarget.stableTargetRef) !== stableRefIdentity(node.targetRef)) {
+    context.addIssue({ code: "custom", path: ["resolvedTarget"], message: "Resolved target identity must match the source node." });
+  }
+  if (node.resolvedTarget.kind === "unavailable" && (node.disabled !== true || Object.keys(node.parameterMapping).length > 0)) {
+    context.addIssue({ code: "custom", path: ["resolvedTarget"], message: "Unavailable targets must be disabled and contain no executable input." });
+  }
+});
 var CompiledNavigationSeparatorNodeSchema = NavigationSeparatorNodeSchema.extend({
   ancestorAccessPolicies: z9.array(AccessPolicySchema)
 }).strict();
@@ -11407,7 +11425,14 @@ var compileNavigationRuntimeBundle = (input) => {
   assertUniqueRegistryKeys(targetRegistry.map((registration) => stableRefKey(registration.stableTargetRef)), "targetRegistry");
   const targetsByStableRef = new Map(targetRegistry.map((registration) => [stableRefKey(registration.stableTargetRef), registration]));
   const releasedByNodeId = new Map(release.resolvedTargets.map((target) => [target.nodeId, target]));
+  const unavailableByNodeId = new Map((release.unavailableTargets ?? []).map((target) => [target.nodeId, target]));
   const nodesById = new Map(navigation.nodes.map((node) => [node.nodeId, node]));
+  for (const target of release.unavailableTargets ?? []) {
+    const node = nodesById.get(target.nodeId);
+    if (node?.kind !== "target" || !sameStableRef(node.targetRef, target.stableTargetRef)) {
+      throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "release.unavailableTargets", "An unavailable target must identify its source Page node exactly.");
+    }
+  }
   const nodes = orderedNavigationNodes(navigation).map((node, index) => {
     const ancestors = [];
     let parentId = node.parentNodeId;
@@ -11422,6 +11447,25 @@ var compileNavigationRuntimeBundle = (input) => {
     }
     const registration = targetsByStableRef.get(stableRefKey(node.targetRef));
     const released = releasedByNodeId.get(node.nodeId);
+    const unavailable = unavailableByNodeId.get(node.nodeId);
+    if (!registration && unavailable && node.targetRef.kind === "page" && sameStableRef(unavailable.stableTargetRef, node.targetRef)) {
+      assertTenantCompatible(node.targetRef, scope, `nodes[${index}].targetRef`);
+      if (unavailable.accessPolicy && !accessPolicyChainImplies([...ancestors, node.audience], unavailable.accessPolicy)) {
+        throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `nodes[${index}].audience`, "Effective Navigation audience is wider than the last verified target audience.");
+      }
+      return {
+        ...node,
+        disabled: true,
+        parameterMapping: {},
+        ancestorAccessPolicies: ancestors,
+        resolvedTarget: {
+          kind: "unavailable",
+          nodeId: node.nodeId,
+          stableTargetRef: node.targetRef,
+          accessPolicy: unavailable.accessPolicy
+        }
+      };
+    }
     if (!registration || !released || !sameStableRef(registration.stableTargetRef, stableFromRevision(registration.targetRevisionRef)) || !sameStableRef(registration.stableTargetRef, released.stableTargetRef) || !sameRevisionRef(registration.targetRevisionRef, released.targetRevisionRef) || registration.kind === "route" && (Boolean(registration.releaseRevisionRef) !== Boolean(released.releaseRevisionRef) || registration.releaseRevisionRef && released.releaseRevisionRef && !sameRevisionRef(registration.releaseRevisionRef, released.releaseRevisionRef))) {
       throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].targetRef`, "Navigation target is not resolved to the exact active release recorded by NavigationRelease.");
     }
@@ -11551,6 +11595,16 @@ var resolveWorkbenchEntry = (input) => {
   return { status: "forbidden", workbenchId: "" };
 };
 
+// src/runtime/navigation-availability.ts
+var NAVIGATION_UNAVAILABLE_CAPABILITY_HEADER = "x-monkeys-navigation-capabilities";
+var NAVIGATION_UNAVAILABLE_CAPABILITY = "unavailable-pages-v1";
+function projectNavigationCompatibility(bundle, supportsUnavailable) {
+  if (supportsUnavailable || !bundle.nodes.some((node) => node.kind === "target" && node.resolvedTarget.kind === "unavailable")) return bundle;
+  const { contentHash: _hash, ...unsigned } = bundle;
+  const nodes = bundle.nodes.filter((node) => node.kind !== "target" || node.resolvedTarget.kind !== "unavailable");
+  return NavigationRuntimeBundleSchema.parse({ ...unsigned, nodes, contentHash: canonicalContentHash({ ...unsigned, nodes }) });
+}
+
 // src/runtime/menu-compiler.ts
 var MenuCompilationError = class extends Error {
   constructor(code, path, message) {
@@ -11823,6 +11877,13 @@ var compileMenuRuntimeBundle = (input) => {
   const contributionProviders = input.contributionProviders.map((registration) => MenuContributionProviderRegistrationSchema.parse(registration));
   const inputValidators = input.inputValidators ?? /* @__PURE__ */ new Map();
   const knownPermissions = new Set(input.permissionCodes.map((permission) => ContractIdentifierSchema.parse(permission)));
+  const completeApplications = new Set(input.missingPagePolicy?.completeApplicationIds.map((id) => ContractIdentifierSchema.parse(id)) ?? []);
+  const unavailableAccess = input.missingPagePolicy ? MenuAccessRequirementSchema.parse(input.missingPagePolicy.unavailableAccess) : void 0;
+  if (unavailableAccess) {
+    validatePermissionCodes(unavailableAccess.permissionAllOf, knownPermissions, "missingPagePolicy.unavailableAccess.permissionAllOf");
+    validatePermissionCodes(unavailableAccess.permissionAnyOf, knownPermissions, "missingPagePolicy.unavailableAccess.permissionAnyOf");
+  }
+  const diagnostics = [];
   pages.forEach((registration, index) => {
     if (!registration.page.visibility.productContexts.some((context) => context === registration.applicationId)) {
       throw new MenuCompilationError(
@@ -11887,6 +11948,35 @@ var compileMenuRuntimeBundle = (input) => {
       if (node.behavior.kind === "navigate") {
         const registration = pagesByKey.get(pageKey(node.behavior.page));
         if (!registration) {
+          if (unavailableAccess && completeApplications.has(node.behavior.page.applicationId)) {
+            const activationId2 = resolveMenuActivationId(node.behavior.page, node.behavior.activationId);
+            const identity2 = targetKey(node.behavior.page, activationId2);
+            const signature2 = stableSerialize2({ ...node.behavior, activationId: activationId2 });
+            const previous = targetSourceSignatures.get(identity2);
+            if (previous !== void 0 && previous !== signature2) {
+              throw new MenuCompilationError("conflicting-navigation-target", `${nodePath}.behavior`, "Missing navigation target has conflicting behavior or input.");
+            }
+            targetSourceSignatures.set(identity2, signature2);
+            if (definition.applicationId === applicationId) {
+              diagnostics.push({
+                code: "missing-page",
+                severity: "warning",
+                applicationId: definition.applicationId,
+                surface: definition.surface,
+                menuId: definition.menuId,
+                nodeId: node.nodeId,
+                page: node.behavior.page,
+                path: `${nodePath}.behavior.page`
+              });
+            }
+            const { requiredPermission: requiredPermission3, behavior: _behavior3, ...presentation3 } = node;
+            return CompiledMenuItemNodeSchema.parse({
+              ...presentation3,
+              disabled: true,
+              behavior: { kind: "navigate", page: node.behavior.page, activationId: activationId2 },
+              access: { ...unavailableAccess, requiredPermission: requiredPermission3 }
+            });
+          }
           throw new MenuCompilationError(
             "unknown-page",
             `${nodePath}.behavior.page`,
@@ -12049,6 +12139,7 @@ var compileMenuRuntimeBundle = (input) => {
   };
   return Object.freeze({
     document: deepFreeze2(document),
+    diagnostics: deepFreeze2(diagnostics),
     menusByKey,
     navigationTargetsByKey: documentTargetsByKey,
     serverInputByTargetKey,
@@ -15756,9 +15847,105 @@ var compileWorkflowPersistenceProjection = (input) => {
   });
 };
 
-// src/contracts/access.ts
+// src/contracts/workflow-column.ts
 import { z as z13 } from "zod";
-var PermissionDefinitionSchema = z13.object({
+var WorkflowColumnFieldRefSchema = z13.object({
+  ontologyId: ContractIdentifierSchema,
+  fieldKey: ContractIdentifierSchema
+}).strict();
+var WorkflowColumnInputSchema = z13.discriminatedUnion("kind", [
+  z13.object({ kind: z13.literal("default") }).strict(),
+  z13.object({ kind: z13.literal("constant"), value: JsonValueSchema }).strict(),
+  z13.object({ kind: z13.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z13.object({
+    kind: z13.literal("context"),
+    field: z13.enum(["assetId", "teamId", "ontologyId", "columnId"])
+  }).strict()
+]);
+var WorkflowColumnDependencySchema = z13.discriminatedUnion("kind", [
+  z13.object({ kind: z13.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z13.object({
+    kind: z13.literal("relation"),
+    relation: WorkflowColumnFieldRefSchema,
+    direction: z13.enum(["incoming", "outgoing"]),
+    fields: z13.array(WorkflowColumnFieldRefSchema).max(100)
+  }).strict()
+]);
+var WorkflowColumnOutputPathSchema = z13.array(z13.string().min(1).max(256)).max(20);
+var WorkflowColumnOutputSchema = z13.object({
+  type: z13.enum(["number", "text", "json"]),
+  path: WorkflowColumnOutputPathSchema,
+  nullable: z13.boolean().default(false)
+}).strict();
+var WorkflowColumnBindingSchema = z13.object({
+  contract: z13.literal("WorkflowColumnBinding"),
+  version: z13.literal(1),
+  enabled: z13.boolean(),
+  paused: z13.boolean().default(false),
+  workflow: z13.object({
+    id: ContractIdentifierSchema,
+    version: z13.number().int().positive(),
+    inputSchemaHash: Sha256Schema
+  }).strict(),
+  inputs: z13.record(z13.string().min(1).max(128), WorkflowColumnInputSchema),
+  dependencies: z13.array(WorkflowColumnDependencySchema).max(100).default([]),
+  output: WorkflowColumnOutputSchema,
+  policy: z13.object({
+    debounceMs: z13.number().int().min(0).max(3e4).default(5e3),
+    maxDelayMs: z13.number().int().min(0).max(3e4).default(3e4),
+    concurrency: z13.number().int().min(1).max(32).default(2)
+  }).strict().default({ debounceMs: 5e3, maxDelayMs: 3e4, concurrency: 2 }),
+  // The workflow supplies an ISO datetime with offset for one future expiry.
+  // Scheduling infrastructure needs no knowledge of months or business periods.
+  expiry: z13.object({ path: WorkflowColumnOutputPathSchema }).strict().optional()
+}).strict();
+
+// src/runtime/workflow-column.ts
+function parseWorkflowColumnBinding(value) {
+  const binding = WorkflowColumnBindingSchema.parse(value);
+  if (Object.keys(binding.inputs).length > 100)
+    throw new Error("Workflow column supports at most 100 input bindings.");
+  if (binding.policy.maxDelayMs < binding.policy.debounceMs)
+    throw new Error("Workflow column maxDelayMs must be at least debounceMs.");
+  for (const name of Object.keys(binding.inputs)) {
+    if (name !== name.trim() || name.startsWith("__") || name === "constructor" || name === "prototype") {
+      throw new Error(`Invalid Workflow input name: ${name}`);
+    }
+  }
+  return binding;
+}
+function selectOwnValue(payload, path) {
+  let value = payload;
+  for (const key of path) {
+    if (value === null || typeof value !== "object" || !Object.prototype.hasOwnProperty.call(value, key)) {
+      throw new Error(`Workflow output is missing the configured path: ${JSON.stringify(path)}`);
+    }
+    value = value[key];
+  }
+  if (value === void 0) throw new Error("Workflow output is absent.");
+  return value;
+}
+function resolveWorkflowColumnResult(binding, payload, nowMs = Date.now()) {
+  const selected = selectOwnValue(payload, binding.output.path);
+  if (selected === null && !binding.output.nullable)
+    throw new Error("Workflow output is null but this column does not allow null results.");
+  if (selected !== null) {
+    if (binding.output.type === "number" && (typeof selected !== "number" || !Number.isFinite(selected)))
+      throw new Error("Workflow output must be a finite number.");
+    if (binding.output.type === "text" && typeof selected !== "string")
+      throw new Error("Workflow output must be text.");
+  }
+  const value = JsonValueSchema.parse(selected);
+  if (!binding.expiry) return { value };
+  const expiresAt = IsoDateTimeSchema.parse(selectOwnValue(payload, binding.expiry.path));
+  if (!Number.isFinite(nowMs) || Date.parse(expiresAt) <= nowMs)
+    throw new Error("Workflow expiry must be a future datetime.");
+  return { value, expiresAt };
+}
+
+// src/contracts/access.ts
+import { z as z14 } from "zod";
+var PermissionDefinitionSchema = z14.object({
   code: ContractIdentifierSchema,
   name: LocalizedTextSchema,
   description: LocalizedTextSchema.optional(),
@@ -15766,29 +15953,29 @@ var PermissionDefinitionSchema = z13.object({
   action: ContractIdentifierSchema,
   domain: ContractIdentifierSchema.optional()
 }).strict();
-var PermissionBundleSchema = z13.object({
+var PermissionBundleSchema = z14.object({
   bundleId: ContractIdentifierSchema,
   name: LocalizedTextSchema,
-  permissionCodes: z13.array(ContractIdentifierSchema).default([])
+  permissionCodes: z14.array(ContractIdentifierSchema).default([])
 }).strict();
-var SystemGroupDefinitionSchema = z13.object({
+var SystemGroupDefinitionSchema = z14.object({
   groupCode: ContractIdentifierSchema,
   name: LocalizedTextSchema,
   description: LocalizedTextSchema.optional(),
-  permissionPolicy: z13.enum(["bundles", "studio_current", "all_current"]).default("bundles"),
-  permissionBundleIds: z13.array(ContractIdentifierSchema).default([])
+  permissionPolicy: z14.enum(["bundles", "studio_current", "all_current"]).default("bundles"),
+  permissionBundleIds: z14.array(ContractIdentifierSchema).default([])
 }).strict().refine((value) => value.permissionPolicy !== "bundles" || value.permissionBundleIds.length > 0, {
   message: "A bundles permission policy requires at least one permission bundle.",
   path: ["permissionBundleIds"]
 });
-var ProductAccessDeclarationSchema = z13.object({
-  contract: z13.literal("ProductAccessDeclaration"),
+var ProductAccessDeclarationSchema = z14.object({
+  contract: z14.literal("ProductAccessDeclaration"),
   declarationId: ContractIdentifierSchema,
   version: ContractVersionSchema,
   ownerRepo: ContractIdentifierSchema,
-  permissions: z13.array(PermissionDefinitionSchema).default([]),
-  permissionBundles: z13.array(PermissionBundleSchema).default([]),
-  systemGroups: z13.array(SystemGroupDefinitionSchema).min(1)
+  permissions: z14.array(PermissionDefinitionSchema).default([]),
+  permissionBundles: z14.array(PermissionBundleSchema).default([]),
+  systemGroups: z14.array(SystemGroupDefinitionSchema).min(1)
 }).strict();
 
 // src/runtime/access-compiler.ts
@@ -15852,6 +16039,8 @@ export {
   DeclarativeControlCompilationError,
   MONKEYS_REQUIRED_THEME_TOKEN_PATHS,
   MenuCompilationError,
+  NAVIGATION_UNAVAILABLE_CAPABILITY,
+  NAVIGATION_UNAVAILABLE_CAPABILITY_HEADER,
   ThemeTokenValidationError,
   accessPolicyChainImplies,
   applyViewRuntimeBindings,
@@ -15895,13 +16084,16 @@ export {
   materializeRouteSpacePath,
   mergeThemeTokenDocuments,
   parseApplicationHandoff,
+  parseWorkflowColumnBinding,
   projectAgentSessionEvents,
+  projectNavigationCompatibility,
   publishOpenApiToolCapabilityManifests,
   readApplicationHandoffFromUrl,
   readMenuActivationFromSearch,
   resolveMenuActivationId,
   resolveThemeTokens,
   resolveWorkbenchEntry,
+  resolveWorkflowColumnResult,
   revisionRefKey,
   sameRevisionRef,
   sameStableRef,